
;
;
;     Model statements for module:  Create 4
;

555$          CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c1:MinutesToBaseTime(1440):NEXT(556$);

556$          ASSIGN:        Create for receiving b shift1 c1.NumberOut=Create for receiving b shift1 c1.NumberOut + 1
                             :NEXT(115$);


;
;
;     Model statements for module:  Decide 98
;
115$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),559$,Yes:
                             Else,560$,Yes;
559$          ASSIGN:        Decide 98.NumberOut True=Decide 98.NumberOut True + 1:NEXT(541$);

560$          ASSIGN:        Decide 98.NumberOut False=Decide 98.NumberOut False + 1:NEXT(116$);


;
;
;     Model statements for module:  Assign 198
;
541$          ASSIGN:        receiptb1# c1=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,67)
                             :NEXT(117$);


;
;
;     Model statements for module:  Decide 99
;
117$          BRANCH,        1:
                             If,receiptb1# c1==0,95$,Yes:
                             If,receiptb1# c1==1,118$,Yes:
                             Else,119$,Yes;

;
;
;     Model statements for module:  Separate 5
;
119$          DUPLICATE,     100 - 50:
                             receiptb1# c1-1,565$,50:NEXT(564$);

564$          ASSIGN:        Separate 5.NumberOut Orig=Separate 5.NumberOut Orig + 1:NEXT(118$);

565$          ASSIGN:        Separate 5.NumberOut Dup=Separate 5.NumberOut Dup + 1:NEXT(118$);


;
;
;     Model statements for module:  Process 10
;
118$          ASSIGN:        Process 10.NumberIn=Process 10.NumberIn + 1:
                             Process 10.WIP=Process 10.WIP+1;
595$          STACK,         1:Save:NEXT(569$);

569$          QUEUE,         Process 10.Queue;
568$          SEIZE,         2,VA:
                             Resource 4_1,1:NEXT(567$);

567$          DELAY:         HoursToBaseTime(expo(10/receiptb1# c1,3)),,VA:NEXT(610$);

610$          ASSIGN:        Process 10.WaitTime=Process 10.WaitTime + Diff.WaitTime;
574$          TALLY:         Process 10.WaitTimePerEntity,Diff.WaitTime,1;
576$          TALLY:         Process 10.TotalTimePerEntity,Diff.StartTime,1;
600$          ASSIGN:        Process 10.VATime=Process 10.VATime + Diff.VATime;
601$          TALLY:         Process 10.VATimePerEntity,Diff.VATime,1;
566$          RELEASE:       Resource 4_1,1;
615$          STACK,         1:Destroy:NEXT(614$);

614$          ASSIGN:        Process 10.NumberOut=Process 10.NumberOut + 1:
                             Process 10.WIP=Process 10.WIP-1:NEXT(87$);


;
;
;     Model statements for module:  Assign 57
;
87$           ASSIGN:        producttype=2:NEXT(180$);


;
;
;     Model statements for module:  Decide 121
;
180$          BRANCH,        1:
                             If,producttype==1,179$,Yes:
                             If,producttype==2,181$,Yes:
                             Else,182$,Yes;
182$          COUNT:         receiptctruck,1:NEXT(173$);


;
;
;     Model statements for module:  Assign 78
;
173$          ASSIGN:        receiptqenter=tnow:NEXT(171$);

171$          QUEUE,         receiptdockqueue;
161$          SEIZE,         2,Other:
                             SELECT(Docks,LRC,index),1:NEXT(162$);


;
;
;     Model statements for module:  Decide 116
;
162$          BRANCH,        1:
                             If,docks(index)==dock1,619$,Yes:
                             Else,620$,Yes;
619$          ASSIGN:        Decide 116.NumberOut True=Decide 116.NumberOut True + 1:NEXT(174$);

620$          ASSIGN:        Decide 116.NumberOut False=Decide 116.NumberOut False + 1:NEXT(297$);

174$          TALLY:         time in receiptq at d1,tnow-receiptqenter,1:NEXT(1$);


;
;
;     Model statements for module:  Assign 2
;
1$            ASSIGN:        truckcap=8:
                             dockno=1:NEXT(2$);

2$            DUPLICATE:     truckcap-1,551$:NEXT(551$);


;
;
;     Model statements for module:  Decide 241
;
551$          BRANCH,        1:
                             If,((STATE(Trans3)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),69$,Yes:
                             If,((STATE(Trans2)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),69$,Yes:
                             If,((STATE(Trans1)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),552$,Yes:
                             Else,543$,Yes;

;
;
;     Model statements for module:  Process 78
;
543$          ASSIGN:        Unloading from dock1_2.NumberIn=Unloading from dock1_2.NumberIn + 1:
                             Unloading from dock1_2.WIP=Unloading from dock1_2.WIP+1;
652$          STACK,         1:Save:NEXT(626$);

626$          QUEUE,         Unloading from dock1_2.Queue;
625$          SEIZE,         1,VA:
                             SELECT(TransSet4,SNB, ),1:NEXT(624$);

624$          DELAY:         SecondsToBaseTime(UNIF(62,83,61)),,VA:NEXT(667$);

667$          ASSIGN:        Unloading from dock1_2.WaitTime=Unloading from dock1_2.WaitTime + Diff.WaitTime;
631$          TALLY:         Unloading from dock1_2.WaitTimePerEntity,Diff.WaitTime,1;
633$          TALLY:         Unloading from dock1_2.TotalTimePerEntity,Diff.StartTime,1;
657$          ASSIGN:        Unloading from dock1_2.VATime=Unloading from dock1_2.VATime + Diff.VATime;
658$          TALLY:         Unloading from dock1_2.VATimePerEntity,Diff.VATime,1;
623$          RELEASE:       SELECT(TransSet4,LAST),1;
672$          STACK,         1:Destroy:NEXT(671$);

671$          ASSIGN:        Unloading from dock1_2.NumberOut=Unloading from dock1_2.NumberOut + 1:
                             Unloading from dock1_2.WIP=Unloading from dock1_2.WIP-1:NEXT(299$);


;
;
;     Model statements for module:  Assign 110
;
299$          ASSIGN:        beginning time for putaway from d1=tnow:NEXT(165$);

165$          ASSIGN:        product3stock=(producttype==3)*(product3stock+1)+(producttype<>3)*(product3stock+0):
                             product2stock=(producttype==2)*(product2stock+1)+(producttype<>2)*(product2stock+0):
                             product1stock=(producttype==1)*(product1stock+1)+(producttype<>1)*(product1stock+0);
167$          WRITE,         stockr:
                             totalstock,
                             tnow:NEXT(3$);


;
;
;     Model statements for module:  Assign 3
;
3$            ASSIGN:        i=1:NEXT(4$);


;
;
;     Model statements for module:  Assign 4
;
4$            ASSIGN:        replaced=0:NEXT(5$);

5$            WHILE:         (replaced==0):NEXT(8$);


;
;
;     Model statements for module:  Decide 3
;
8$            BRANCH,        1:
                             If,(LocationA(i,1) == 0) ||  ( (producttype  ==  LocationA (i,2)) && (LocationA(i,1) < Capacity) ),
                             674$,Yes:
                             Else,675$,Yes;
674$          ASSIGN:        Decide 3.NumberOut True=Decide 3.NumberOut True + 1:NEXT(7$);

675$          ASSIGN:        Decide 3.NumberOut False=Decide 3.NumberOut False + 1:NEXT(10$);

7$            ASSIGN:        LocationA(i,1)=LocationA(i,1)+1:
                             LocationA(i,2)=producttype:NEXT(11$);


;
;
;     Model statements for module:  Assign 11
;
11$           ASSIGN:        Locationtype=1:NEXT(57$);


;
;
;     Model statements for module:  Decide 45
;
57$           BRANCH,        1:
                             If,dockno==1,676$,Yes:
                             Else,677$,Yes;
676$          ASSIGN:        Decide 45.NumberOut True=Decide 45.NumberOut True + 1:NEXT(508$);

677$          ASSIGN:        Decide 45.NumberOut False=Decide 45.NumberOut False + 1:NEXT(507$);


;
;
;     Model statements for module:  Assign 183
;
508$          ASSIGN:        width1=
                             (LocationA(i,1)==1)*4+(LocationA(i,1)==2)*3+(LocationA(i,1)==3)*2+(LocationA(i,1)==4)*1+(LocationA(i,1)==5)*0:
                             distance1=20+i*1+width1:NEXT(13$);


;
;
;     Model statements for module:  Assign 13
;
13$           ASSIGN:        replaced=1:NEXT(14$);

14$           ENDWHILE:NEXT(54$);


;
;
;     Model statements for module:  Decide 44
;
54$           BRANCH,        1:
                             If,dockno==1,678$,Yes:
                             Else,679$,Yes;
678$          ASSIGN:        Decide 44.NumberOut True=Decide 44.NumberOut True + 1:NEXT(16$);

679$          ASSIGN:        Decide 44.NumberOut False=Decide 44.NumberOut False + 1:NEXT(55$);


;
;
;     Model statements for module:  Seize 2
;
16$           QUEUE,         Seizing a forklift from forklift set at receiving ramp1.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet1,CYC, trans_no1),1:NEXT(681$);

681$          DELAY:         0.0,,VA:NEXT(527$);


;
;
;     Model statements for module:  Decide 229
;
527$          BRANCH,        1:
                             If,stock exceeded<>1,682$,Yes:
                             Else,683$,Yes;
682$          ASSIGN:        Decide 229.NumberOut True=Decide 229.NumberOut True + 1:NEXT(18$);

683$          ASSIGN:        Decide 229.NumberOut False=Decide 229.NumberOut False + 1:NEXT(528$);


;
;
;     Model statements for module:  Delay 1
;
18$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance1)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance3)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance5)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance7)+NORM(0,7.3))*2)),,
                             Other:NEXT(19$);

19$           RELEASE:       Member(TransSet1, Trans_No1),1;
301$          TALLY:         time for putaway from d1,tnow-beginning time for putaway from d1,1;
211$          ASSIGN:        #unloaded1=#unloaded1+1:NEXT(20$);


;
;
;     Model statements for module:  Decide 6
;
20$           BRANCH,        1:
                             If,#unloaded1==truckcap,684$,Yes:
                             Else,685$,Yes;
684$          ASSIGN:        Decide 6.NumberOut True=Decide 6.NumberOut True + 1:NEXT(21$);

685$          ASSIGN:        Decide 6.NumberOut False=Decide 6.NumberOut False + 1:NEXT(15$);


;
;
;     Model statements for module:  Release 1
;
21$           RELEASE:       dock1,1:NEXT(184$);

184$          TALLY:         time in system from d1,tnow-receiptqenter,1;
212$          ASSIGN:        #unloaded1=#unloaded1-#unloaded1:NEXT(15$);


;
;
;     Model statements for module:  Dispose 1
;
15$           ASSIGN:        Dispose 1.NumberOut=Dispose 1.NumberOut + 1;
686$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Delay 14
;
528$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(19$);


;
;
;     Model statements for module:  Seize 15
;
55$           QUEUE,         Seizing a forklift from forklift set at receiving ramp2.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet2,CYC, trans_no2),1:NEXT(688$);

688$          DELAY:         0.0,,VA:NEXT(530$);


;
;
;     Model statements for module:  Decide 230
;
530$          BRANCH,        1:
                             If,stock exceeded<>1,689$,Yes:
                             Else,690$,Yes;
689$          ASSIGN:        Decide 230.NumberOut True=Decide 230.NumberOut True + 1:NEXT(58$);

690$          ASSIGN:        Decide 230.NumberOut False=Decide 230.NumberOut False + 1:NEXT(529$);


;
;
;     Model statements for module:  Delay 11
;
58$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance2)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance4)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance6)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance8)+NORM(0,7.3))*2)),,
                             Other:NEXT(59$);

59$           RELEASE:       Member(TransSet2, Trans_No2),1;
302$          TALLY:         time for putaway from d2,tnow-beginning time for putaway from d2,1;
213$          ASSIGN:        #unloaded2=#unloaded2+1:NEXT(61$);


;
;
;     Model statements for module:  Decide 56
;
61$           BRANCH,        1:
                             If,#unloaded2==truckcap,691$,Yes:
                             Else,692$,Yes;
691$          ASSIGN:        Decide 56.NumberOut True=Decide 56.NumberOut True + 1:NEXT(62$);

692$          ASSIGN:        Decide 56.NumberOut False=Decide 56.NumberOut False + 1:NEXT(60$);


;
;
;     Model statements for module:  Release 15
;
62$           RELEASE:       dock2,1:NEXT(183$);

183$          TALLY:         time in system from d2,tnow-receiptqenter,1;
214$          ASSIGN:        #unloaded2=#unloaded2-#unloaded2:NEXT(60$);


;
;
;     Model statements for module:  Dispose 15
;
60$           ASSIGN:        Dispose 15.NumberOut=Dispose 15.NumberOut + 1;
693$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Delay 15
;
529$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(59$);


;
;
;     Model statements for module:  Assign 182
;
507$          ASSIGN:        width2=
                             (LocationA(i,1)==1)*4+(LocationA(i,1)==2)*3+(LocationA(i,1)==3)*2+(LocationA(i,1)==4)*1+(LocationA(i,1)==5)*0:
                             distance2=23+i*1+width2:NEXT(13$);


;
;
;     Model statements for module:  Decide 4
;
10$           BRANCH,        1:
                             If,
                             ((LocationB(i,1) == 0) ||  ( (producttype  ==  LocationB (i,2)) && (LocationB(i,1) < Capacity) )),
                             694$,Yes:
                             Else,695$,Yes;
694$          ASSIGN:        Decide 4.NumberOut True=Decide 4.NumberOut True + 1:NEXT(6$);

695$          ASSIGN:        Decide 4.NumberOut False=Decide 4.NumberOut False + 1:NEXT(71$);

6$            ASSIGN:        LocationB(i,1)=LocationB(i,1)+1:
                             LocationB(i,2)=producttype:NEXT(12$);


;
;
;     Model statements for module:  Assign 12
;
12$           ASSIGN:        Locationtype=2:NEXT(509$);


;
;
;     Model statements for module:  Decide 223
;
509$          BRANCH,        1:
                             If,dockno==1,696$,Yes:
                             Else,697$,Yes;
696$          ASSIGN:        Decide 223.NumberOut True=Decide 223.NumberOut True + 1:NEXT(510$);

697$          ASSIGN:        Decide 223.NumberOut False=Decide 223.NumberOut False + 1:NEXT(511$);


;
;
;     Model statements for module:  Assign 184
;
510$          ASSIGN:        width3=
                             (LocationB(i,1)==1)*4+(LocationB(i,1)==2)*3+(LocationB(i,1)==3)*2+(LocationB(i,1)==4)*1+(LocationB(i,1)==5)*0:
                             distance3=20+i*1+width3:NEXT(13$);


;
;
;     Model statements for module:  Assign 186
;
511$          ASSIGN:        width4=
                             (LocationB(i,1)==1)*4+(LocationB(i,1)==2)*3+(LocationB(i,1)==3)*2+(LocationB(i,1)==4)*1+(LocationB(i,1)==5)*0:
                             distance4=23+i*1+width4:NEXT(13$);


;
;
;     Model statements for module:  Decide 67
;
71$           BRANCH,        1:
                             If,((LocationC(i,1) == 0) ||  ( (producttype  ==  LocationC (i,2)) && (LocationC(i,1) < 8) )),698$,
                             Yes:
                             Else,699$,Yes;
698$          ASSIGN:        Decide 67.NumberOut True=Decide 67.NumberOut True + 1:NEXT(72$);

699$          ASSIGN:        Decide 67.NumberOut False=Decide 67.NumberOut False + 1:NEXT(150$);

72$           ASSIGN:        LocationC(i,1)=LocationC(i,1)+1:
                             LocationC(i,2)=producttype:NEXT(73$);


;
;
;     Model statements for module:  Assign 49
;
73$           ASSIGN:        Locationtype=3:NEXT(74$);


;
;
;     Model statements for module:  Decide 68
;
74$           BRANCH,        1:
                             If,dockno==1,700$,Yes:
                             Else,701$,Yes;
700$          ASSIGN:        Decide 68.NumberOut True=Decide 68.NumberOut True + 1:NEXT(75$);

701$          ASSIGN:        Decide 68.NumberOut False=Decide 68.NumberOut False + 1:NEXT(76$);


;
;
;     Model statements for module:  Assign 51
;
75$           ASSIGN:        width5=
                             (LocationC(i,1)==1)*7+(LocationC(i,1)==2)*6+(LocationC(i,1)==3)*5+(LocationC(i,1)==4)*4+(LocationC(i,1)==5)*3+(LocationC(i,1)==6)*2+(LocationC(i,1)==7)*1+(LocationC(i,1)==8)*0:
                             distance5=13+i*1+width5:NEXT(13$);


;
;
;     Model statements for module:  Assign 52
;
76$           ASSIGN:        width6=
                             (LocationC(i,1)==1)*7+(LocationC(i,1)==2)*6+(LocationC(i,1)==3)*5+(LocationC(i,1)==4)*4+(LocationC(i,1)==5)*3+(LocationC(i,1)==6)*2+(LocationC(i,1)==7)*1+(LocationC(i,1)==8)*0:
                             distance6=14+i*1+width6:NEXT(13$);


;
;
;     Model statements for module:  Decide 110
;
150$          BRANCH,        1:
                             If,((LocationD(i,1) == 0) ||  ( (producttype  ==  LocationD (i,2)) && (LocationD(i,1) < 8) )),702$,
                             Yes:
                             Else,703$,Yes;
702$          ASSIGN:        Decide 110.NumberOut True=Decide 110.NumberOut True + 1:NEXT(151$);

703$          ASSIGN:        Decide 110.NumberOut False=Decide 110.NumberOut False + 1:NEXT(9$);

151$          ASSIGN:        LocationD(i,1)=LocationD(i,1)+1:
                             LocationD(i,2)=producttype:NEXT(152$);


;
;
;     Model statements for module:  Assign 76
;
152$          ASSIGN:        Locationtype=4:NEXT(512$);


;
;
;     Model statements for module:  Decide 224
;
512$          BRANCH,        1:
                             If,dockno==1,704$,Yes:
                             Else,705$,Yes;
704$          ASSIGN:        Decide 224.NumberOut True=Decide 224.NumberOut True + 1:NEXT(513$);

705$          ASSIGN:        Decide 224.NumberOut False=Decide 224.NumberOut False + 1:NEXT(514$);


;
;
;     Model statements for module:  Assign 189
;
513$          ASSIGN:        width7=
                             (LocationD(i,1)==1)*7+(LocationD(i,1)==2)*6+(LocationD(i,1)==3)*5+(LocationD(i,1)==4)*4+(LocationD(i,1)==5)*3+(LocationD(i,1)==6)*2+(LocationD(i,1)==7)*1+(LocationD(i,1)==8)*0:
                             distance7=13+i*1+width7:NEXT(13$);


;
;
;     Model statements for module:  Assign 190
;
514$          ASSIGN:        width8=
                             (LocationD(i,1)==1)*7+(LocationD(i,1)==2)*6+(LocationD(i,1)==3)*5+(LocationD(i,1)==4)*4+(LocationD(i,1)==5)*3+(LocationD(i,1)==6)*2+(LocationD(i,1)==7)*1+(LocationD(i,1)==8)*0:
                             distance8=14+i*1+width8:NEXT(13$);


;
;
;     Model statements for module:  Assign 10
;
9$            ASSIGN:        i=i+1:NEXT(525$);


;
;
;     Model statements for module:  Decide 228
;
525$          BRANCH,        1:
                             If,i<=231,706$,Yes:
                             Else,707$,Yes;
706$          ASSIGN:        Decide 228.NumberOut True=Decide 228.NumberOut True + 1:NEXT(14$);

707$          ASSIGN:        Decide 228.NumberOut False=Decide 228.NumberOut False + 1:NEXT(526$);


;
;
;     Model statements for module:  Assign 196
;
526$          ASSIGN:        stock exceeded=1:NEXT(521$);


;
;
;     Model statements for module:  Decide 227
;
521$          BRANCH,        1:
                             If,producttype==1,522$,Yes:
                             If,producttype==2,523$,Yes:
                             Else,524$,Yes;
524$          ASSIGN:        stock3=stock3+1:NEXT(54$);

522$          ASSIGN:        stock1=stock1+1:NEXT(54$);

523$          ASSIGN:        stock2=stock2+1:NEXT(54$);


;
;
;     Model statements for module:  Process 1
;
69$           ASSIGN:        Unloading from dock1.NumberIn=Unloading from dock1.NumberIn + 1:
                             Unloading from dock1.WIP=Unloading from dock1.WIP+1;
739$          STACK,         1:Save:NEXT(713$);

713$          QUEUE,         Unloading from dock1.Queue;
712$          SEIZE,         1,VA:
                             SELECT(TransSeta,SNB, ),1:NEXT(711$);

711$          DELAY:         SecondsToBaseTime(UNIF(62,83,61)),,VA:NEXT(754$);

754$          ASSIGN:        Unloading from dock1.WaitTime=Unloading from dock1.WaitTime + Diff.WaitTime;
718$          TALLY:         Unloading from dock1.WaitTimePerEntity,Diff.WaitTime,1;
720$          TALLY:         Unloading from dock1.TotalTimePerEntity,Diff.StartTime,1;
744$          ASSIGN:        Unloading from dock1.VATime=Unloading from dock1.VATime + Diff.VATime;
745$          TALLY:         Unloading from dock1.VATimePerEntity,Diff.VATime,1;
710$          RELEASE:       SELECT(TransSeta,LAST),1;
759$          STACK,         1:Destroy:NEXT(758$);

758$          ASSIGN:        Unloading from dock1.NumberOut=Unloading from dock1.NumberOut + 1:
                             Unloading from dock1.WIP=Unloading from dock1.WIP-1:NEXT(299$);


;
;
;     Model statements for module:  Process 85
;
552$          ASSIGN:        Unloading from dock1_1.NumberIn=Unloading from dock1_1.NumberIn + 1:
                             Unloading from dock1_1.WIP=Unloading from dock1_1.WIP+1;
790$          STACK,         1:Save:NEXT(764$);

764$          QUEUE,         Unloading from dock1_1.Queue;
763$          SEIZE,         1,VA:
                             SELECT(TransSetb,SNB, ),1:NEXT(762$);

762$          DELAY:         SecondsToBaseTime(UNIF(62,83,61)),,VA:NEXT(805$);

805$          ASSIGN:        Unloading from dock1_1.WaitTime=Unloading from dock1_1.WaitTime + Diff.WaitTime;
769$          TALLY:         Unloading from dock1_1.WaitTimePerEntity,Diff.WaitTime,1;
771$          TALLY:         Unloading from dock1_1.TotalTimePerEntity,Diff.StartTime,1;
795$          ASSIGN:        Unloading from dock1_1.VATime=Unloading from dock1_1.VATime + Diff.VATime;
796$          TALLY:         Unloading from dock1_1.VATimePerEntity,Diff.VATime,1;
761$          RELEASE:       SELECT(TransSetb,LAST),1;
810$          STACK,         1:Destroy:NEXT(809$);

809$          ASSIGN:        Unloading from dock1_1.NumberOut=Unloading from dock1_1.NumberOut + 1:
                             Unloading from dock1_1.WIP=Unloading from dock1_1.WIP-1:NEXT(299$);

297$          TALLY:         time in receiptq at d2,tnow-receiptqenter,1:NEXT(22$);


;
;
;     Model statements for module:  Assign 15
;
22$           ASSIGN:        truckcap=8:
                             dockno=2:NEXT(23$);

23$           DUPLICATE:     truckcap-1,553$:NEXT(553$);


;
;
;     Model statements for module:  Decide 242
;
553$          BRANCH,        1:
                             If,((STATE(Trans3)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),70$,Yes:
                             If,((STATE(Trans2)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),554$,Yes:
                             If,((STATE(Trans1)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),554$,Yes:
                             Else,544$,Yes;

;
;
;     Model statements for module:  Process 79
;
544$          ASSIGN:        Unloading from dock2_2.NumberIn=Unloading from dock2_2.NumberIn + 1:
                             Unloading from dock2_2.WIP=Unloading from dock2_2.WIP+1;
843$          STACK,         1:Save:NEXT(817$);

817$          QUEUE,         Unloading from dock2_2.Queue;
816$          SEIZE,         1,VA:
                             SELECT(TransSet5,SNB, ),1:NEXT(815$);

815$          DELAY:         SecondsToBaseTime(UNIF(62,83,62)),,VA:NEXT(858$);

858$          ASSIGN:        Unloading from dock2_2.WaitTime=Unloading from dock2_2.WaitTime + Diff.WaitTime;
822$          TALLY:         Unloading from dock2_2.WaitTimePerEntity,Diff.WaitTime,1;
824$          TALLY:         Unloading from dock2_2.TotalTimePerEntity,Diff.StartTime,1;
848$          ASSIGN:        Unloading from dock2_2.VATime=Unloading from dock2_2.VATime + Diff.VATime;
849$          TALLY:         Unloading from dock2_2.VATimePerEntity,Diff.VATime,1;
814$          RELEASE:       SELECT(TransSet5,LAST),1;
863$          STACK,         1:Destroy:NEXT(862$);

862$          ASSIGN:        Unloading from dock2_2.NumberOut=Unloading from dock2_2.NumberOut + 1:
                             Unloading from dock2_2.WIP=Unloading from dock2_2.WIP-1:NEXT(300$);


;
;
;     Model statements for module:  Assign 111
;
300$          ASSIGN:        beginning time for putaway from d2=tnow:NEXT(165$);


;
;
;     Model statements for module:  Process 2
;
70$           ASSIGN:        Unloading from dock2.NumberIn=Unloading from dock2.NumberIn + 1:
                             Unloading from dock2.WIP=Unloading from dock2.WIP+1;
894$          STACK,         1:Save:NEXT(868$);

868$          QUEUE,         Unloading from dock2.Queue;
867$          SEIZE,         1,VA:
                             SELECT(TransSetb,SNB, ),1:NEXT(866$);

866$          DELAY:         SecondsToBaseTime(UNIF(62,83,62)),,VA:NEXT(909$);

909$          ASSIGN:        Unloading from dock2.WaitTime=Unloading from dock2.WaitTime + Diff.WaitTime;
873$          TALLY:         Unloading from dock2.WaitTimePerEntity,Diff.WaitTime,1;
875$          TALLY:         Unloading from dock2.TotalTimePerEntity,Diff.StartTime,1;
899$          ASSIGN:        Unloading from dock2.VATime=Unloading from dock2.VATime + Diff.VATime;
900$          TALLY:         Unloading from dock2.VATimePerEntity,Diff.VATime,1;
865$          RELEASE:       SELECT(TransSetb,LAST),1;
914$          STACK,         1:Destroy:NEXT(913$);

913$          ASSIGN:        Unloading from dock2.NumberOut=Unloading from dock2.NumberOut + 1:
                             Unloading from dock2.WIP=Unloading from dock2.WIP-1:NEXT(300$);


;
;
;     Model statements for module:  Process 86
;
554$          ASSIGN:        Unloading from dock2_1.NumberIn=Unloading from dock2_1.NumberIn + 1:
                             Unloading from dock2_1.WIP=Unloading from dock2_1.WIP+1;
945$          STACK,         1:Save:NEXT(919$);

919$          QUEUE,         Unloading from dock2_1.Queue;
918$          SEIZE,         1,VA:
                             SELECT(TransSetc,SNB, ),1:NEXT(917$);

917$          DELAY:         SecondsToBaseTime(UNIF(62,83,62)),,VA:NEXT(960$);

960$          ASSIGN:        Unloading from dock2_1.WaitTime=Unloading from dock2_1.WaitTime + Diff.WaitTime;
924$          TALLY:         Unloading from dock2_1.WaitTimePerEntity,Diff.WaitTime,1;
926$          TALLY:         Unloading from dock2_1.TotalTimePerEntity,Diff.StartTime,1;
950$          ASSIGN:        Unloading from dock2_1.VATime=Unloading from dock2_1.VATime + Diff.VATime;
951$          TALLY:         Unloading from dock2_1.VATimePerEntity,Diff.VATime,1;
916$          RELEASE:       SELECT(TransSetc,LAST),1;
965$          STACK,         1:Destroy:NEXT(964$);

964$          ASSIGN:        Unloading from dock2_1.NumberOut=Unloading from dock2_1.NumberOut + 1:
                             Unloading from dock2_1.WIP=Unloading from dock2_1.WIP-1:NEXT(300$);

179$          COUNT:         receiptatruck,1:NEXT(173$);

181$          COUNT:         receiptbtruck,1:NEXT(173$);


;
;
;     Model statements for module:  Dispose 16
;
95$           ASSIGN:        Dispose 16.NumberOut=Dispose 16.NumberOut + 1;
967$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 69
;
116$          ASSIGN:        receiptb2# c1=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,68)
                             :NEXT(120$);


;
;
;     Model statements for module:  Decide 100
;
120$          BRANCH,        1:
                             If,receiptb2# c1==0,95$,Yes:
                             If,receiptb2# c1==1,121$,Yes:
                             Else,122$,Yes;

;
;
;     Model statements for module:  Separate 6
;
122$          DUPLICATE,     100 - 50:
                             receiptb2# c1-1,972$,50:NEXT(971$);

971$          ASSIGN:        Separate 6.NumberOut Orig=Separate 6.NumberOut Orig + 1:NEXT(121$);

972$          ASSIGN:        Separate 6.NumberOut Dup=Separate 6.NumberOut Dup + 1:NEXT(121$);


;
;
;     Model statements for module:  Process 11
;
121$          ASSIGN:        Process 11.NumberIn=Process 11.NumberIn + 1:
                             Process 11.WIP=Process 11.WIP+1;
1002$         STACK,         1:Save:NEXT(976$);

976$          QUEUE,         Process 11.Queue;
975$          SEIZE,         2,VA:
                             Resource 5,1:NEXT(974$);

974$          DELAY:         HoursToBaseTime(expo(14/receiptb2# c1,4)),,VA:NEXT(1017$);

1017$         ASSIGN:        Process 11.WaitTime=Process 11.WaitTime + Diff.WaitTime;
981$          TALLY:         Process 11.WaitTimePerEntity,Diff.WaitTime,1;
983$          TALLY:         Process 11.TotalTimePerEntity,Diff.StartTime,1;
1007$         ASSIGN:        Process 11.VATime=Process 11.VATime + Diff.VATime;
1008$         TALLY:         Process 11.VATimePerEntity,Diff.VATime,1;
973$          RELEASE:       Resource 5,1;
1022$         STACK,         1:Destroy:NEXT(1021$);

1021$         ASSIGN:        Process 11.NumberOut=Process 11.NumberOut + 1:
                             Process 11.WIP=Process 11.WIP-1:NEXT(87$);


;
;
;     Model statements for module:  Create 5
;

1024$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c1:MinutesToBaseTime(1440):NEXT(1025$);

1025$         ASSIGN:        Create for receiving c shift1 c1.NumberOut=Create for receiving c shift1 c1.NumberOut + 1
                             :NEXT(123$);


;
;
;     Model statements for module:  Decide 101
;
123$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1028$,Yes:
                             Else,1029$,Yes;
1028$         ASSIGN:        Decide 101.NumberOut True=Decide 101.NumberOut True + 1:NEXT(124$);

1029$         ASSIGN:        Decide 101.NumberOut False=Decide 101.NumberOut False + 1:NEXT(125$);


;
;
;     Model statements for module:  Assign 70
;
124$          ASSIGN:        receiptc1# c1=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,69)
                             :NEXT(126$);


;
;
;     Model statements for module:  Decide 102
;
126$          BRANCH,        1:
                             If,receiptc1# c1==0,95$,Yes:
                             If,receiptc1# c1==1,127$,Yes:
                             Else,128$,Yes;

;
;
;     Model statements for module:  Separate 7
;
128$          DUPLICATE,     100 - 50:
                             receiptc1# c1-1,1034$,50:NEXT(1033$);

1033$         ASSIGN:        Separate 7.NumberOut Orig=Separate 7.NumberOut Orig + 1:NEXT(127$);

1034$         ASSIGN:        Separate 7.NumberOut Dup=Separate 7.NumberOut Dup + 1:NEXT(127$);


;
;
;     Model statements for module:  Process 12
;
127$          ASSIGN:        Process 12.NumberIn=Process 12.NumberIn + 1:
                             Process 12.WIP=Process 12.WIP+1;
1064$         STACK,         1:Save:NEXT(1038$);

1038$         QUEUE,         Process 12.Queue;
1037$         SEIZE,         2,VA:
                             Resource 6,1:NEXT(1036$);

1036$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c1,5)),,VA:NEXT(1079$);

1079$         ASSIGN:        Process 12.WaitTime=Process 12.WaitTime + Diff.WaitTime;
1043$         TALLY:         Process 12.WaitTimePerEntity,Diff.WaitTime,1;
1045$         TALLY:         Process 12.TotalTimePerEntity,Diff.StartTime,1;
1069$         ASSIGN:        Process 12.VATime=Process 12.VATime + Diff.VATime;
1070$         TALLY:         Process 12.VATimePerEntity,Diff.VATime,1;
1035$         RELEASE:       Resource 6,1;
1084$         STACK,         1:Destroy:NEXT(1083$);

1083$         ASSIGN:        Process 12.NumberOut=Process 12.NumberOut + 1:
                             Process 12.WIP=Process 12.WIP-1:NEXT(88$);


;
;
;     Model statements for module:  Assign 58
;
88$           ASSIGN:        producttype=3:NEXT(180$);


;
;
;     Model statements for module:  Assign 71
;
125$          ASSIGN:        receiptc2# c1=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,70)
                             :NEXT(129$);


;
;
;     Model statements for module:  Decide 103
;
129$          BRANCH,        1:
                             If,receiptc2# c1==0,95$,Yes:
                             If,receiptc2# c1==1,130$,Yes:
                             Else,131$,Yes;

;
;
;     Model statements for module:  Separate 8
;
131$          DUPLICATE,     100 - 50:
                             receiptc2# c1-1,1090$,50:NEXT(1089$);

1089$         ASSIGN:        Separate 8.NumberOut Orig=Separate 8.NumberOut Orig + 1:NEXT(130$);

1090$         ASSIGN:        Separate 8.NumberOut Dup=Separate 8.NumberOut Dup + 1:NEXT(130$);


;
;
;     Model statements for module:  Process 13
;
130$          ASSIGN:        Process 13.NumberIn=Process 13.NumberIn + 1:
                             Process 13.WIP=Process 13.WIP+1;
1120$         STACK,         1:Save:NEXT(1094$);

1094$         QUEUE,         Process 13.Queue;
1093$         SEIZE,         2,VA:
                             Resource 7,1:NEXT(1092$);

1092$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c1,6)),,VA:NEXT(1135$);

1135$         ASSIGN:        Process 13.WaitTime=Process 13.WaitTime + Diff.WaitTime;
1099$         TALLY:         Process 13.WaitTimePerEntity,Diff.WaitTime,1;
1101$         TALLY:         Process 13.TotalTimePerEntity,Diff.StartTime,1;
1125$         ASSIGN:        Process 13.VATime=Process 13.VATime + Diff.VATime;
1126$         TALLY:         Process 13.VATimePerEntity,Diff.VATime,1;
1091$         RELEASE:       Resource 7,1;
1140$         STACK,         1:Destroy:NEXT(1139$);

1139$         ASSIGN:        Process 13.NumberOut=Process 13.NumberOut + 1:
                             Process 13.WIP=Process 13.WIP-1:NEXT(88$);


;
;
;     Model statements for module:  Create 6
;

1142$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c1:MinutesToBaseTime(1440):NEXT(1143$);

1143$         ASSIGN:        Create for shipment b shift1 c1.NumberOut=Create for shipment b shift1 c1.NumberOut + 1:NEXT(132$);


;
;
;     Model statements for module:  Decide 104
;
132$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1146$,Yes:
                             Else,1147$,Yes;
1146$         ASSIGN:        Decide 104.NumberOut True=Decide 104.NumberOut True + 1:NEXT(133$);

1147$         ASSIGN:        Decide 104.NumberOut False=Decide 104.NumberOut False + 1:NEXT(134$);


;
;
;     Model statements for module:  Assign 72
;
133$          ASSIGN:        departureb1# c1=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,97):NEXT(135$);


;
;
;     Model statements for module:  Decide 105
;
135$          BRANCH,        1:
                             If,departureb1# c1==0,108$,Yes:
                             If,departureb1# c1==1,136$,Yes:
                             Else,137$,Yes;

;
;
;     Model statements for module:  Separate 9
;
137$          DUPLICATE,     100 - 50:
                             departureb1# c1-1,1152$,50:NEXT(1151$);

1151$         ASSIGN:        Separate 9.NumberOut Orig=Separate 9.NumberOut Orig + 1:NEXT(136$);

1152$         ASSIGN:        Separate 9.NumberOut Dup=Separate 9.NumberOut Dup + 1:NEXT(136$);


;
;
;     Model statements for module:  Process 14
;
136$          ASSIGN:        Process 14.NumberIn=Process 14.NumberIn + 1:
                             Process 14.WIP=Process 14.WIP+1;
1182$         STACK,         1:Save:NEXT(1156$);

1156$         QUEUE,         Process 14.Queue;
1155$         SEIZE,         2,VA:
                             Resource 8,1:NEXT(1154$);

1154$         DELAY:         HoursToBaseTime(expo(10/departureb1# c1,33)),,VA:NEXT(1197$);

1197$         ASSIGN:        Process 14.WaitTime=Process 14.WaitTime + Diff.WaitTime;
1161$         TALLY:         Process 14.WaitTimePerEntity,Diff.WaitTime,1;
1163$         TALLY:         Process 14.TotalTimePerEntity,Diff.StartTime,1;
1187$         ASSIGN:        Process 14.VATime=Process 14.VATime + Diff.VATime;
1188$         TALLY:         Process 14.VATimePerEntity,Diff.VATime,1;
1153$         RELEASE:       Resource 8,1;
1202$         STACK,         1:Destroy:NEXT(1201$);

1201$         ASSIGN:        Process 14.NumberOut=Process 14.NumberOut + 1:
                             Process 14.WIP=Process 14.WIP-1:NEXT(90$);


;
;
;     Model statements for module:  Assign 60
;
90$           ASSIGN:        type=2:NEXT(158$);


;
;
;     Model statements for module:  Decide 115
;
158$          BRANCH,        1:
                             If,type==1,168$,Yes:
                             If,type==2,169$,Yes:
                             Else,170$,Yes;

;
;
;     Model statements for module:  Decide 120
;
170$          BRANCH,        1:
                             If,product3stock>=safety stock,1206$,Yes:
                             Else,1207$,Yes;
1206$         ASSIGN:        Decide 120.NumberOut True=Decide 120.NumberOut True + 1:NEXT(221$);

1207$         ASSIGN:        Decide 120.NumberOut False=Decide 120.NumberOut False + 1:NEXT(160$);

221$          COUNT:         dispatchctruck,1:NEXT(24$);


;
;
;     Model statements for module:  Assign 23
;
24$           ASSIGN:        ordersize=8:
                             shipmentqenter=tnow:NEXT(68$);

68$           ASSIGN:        product2stock=(type==2)*(product2stock-8)+(type<>2)*(product2stock-0):
                             product3stock=(type==3)*(product3stock-8)+(type<>3)*(product3stock-0):
                             product1stock=(type==1)*(product1stock-8)+(type<>1)*(product1stock-0);
166$          WRITE,         stock:
                             totalstock,
                             tnow;
172$          QUEUE,         shipmentdockqueue;
163$          SEIZE,         1,Other:
                             SELECT(S_docks,LRC,s_index),1:NEXT(164$);


;
;
;     Model statements for module:  Decide 117
;
164$          BRANCH,        1:
                             If,s_docks(s_index)==dock1,1208$,Yes:
                             Else,1209$,Yes;
1208$         ASSIGN:        Decide 117.NumberOut True=Decide 117.NumberOut True + 1:NEXT(175$);

1209$         ASSIGN:        Decide 117.NumberOut False=Decide 117.NumberOut False + 1:NEXT(298$);

175$          TALLY:         time in shipmentq at d1,tnow-shipmentqenter,1:NEXT(66$);


;
;
;     Model statements for module:  Assign 47
;
66$           ASSIGN:        dock_no=1:
                             leave the dock1 queue=tnow:NEXT(26$);

26$           DUPLICATE:     ordersize-1,25$:NEXT(25$);


;
;
;     Model statements for module:  Assign 24
;
25$           ASSIGN:        picked=0:
                             k=1:
                             totalstock=product1stock+product2stock+product3stock:
                             totalexceedingstock=stock1+stock2+stock3:NEXT(27$);

27$           WHILE:         (picked==0):NEXT(28$);


;
;
;     Model statements for module:  Decide 17
;
28$           BRANCH,        1:
                             If,( LocationA(k,1) <> 0  )  &&  ( type == LocationA(k,2) ),1210$,Yes:
                             Else,1211$,Yes;
1210$         ASSIGN:        Decide 17.NumberOut True=Decide 17.NumberOut True + 1:NEXT(29$);

1211$         ASSIGN:        Decide 17.NumberOut False=Decide 17.NumberOut False + 1:NEXT(33$);

29$           ASSIGN:        LocationA(k,1)=LocationA(k,1)-1:NEXT(30$);


;
;
;     Model statements for module:  Assign 27
;
30$           ASSIGN:        picked=1:
                             Locationtype=1:NEXT(31$);


;
;
;     Model statements for module:  Decide 18
;
31$           BRANCH,        1:
                             If,LocationA(k,1)==0,1212$,Yes:
                             Else,1213$,Yes;
1212$         ASSIGN:        Decide 18.NumberOut True=Decide 18.NumberOut True + 1:NEXT(32$);

1213$         ASSIGN:        Decide 18.NumberOut False=Decide 18.NumberOut False + 1:NEXT(63$);

32$           ASSIGN:        LocationA(k,2)=0:NEXT(63$);


;
;
;     Model statements for module:  Decide 57
;
63$           BRANCH,        1:
                             If,dock_no==1,1214$,Yes:
                             Else,1215$,Yes;
1214$         ASSIGN:        Decide 57.NumberOut True=Decide 57.NumberOut True + 1:NEXT(64$);

1215$         ASSIGN:        Decide 57.NumberOut False=Decide 57.NumberOut False + 1:NEXT(65$);


;
;
;     Model statements for module:  Assign 43
;
64$           ASSIGN:        width9=
                             (LocationA(k,1)==4)*0+(LocationA(k,1)==3)*1+(LocationA(k,1)==2)*2+(LocationA(k,1)==1)*3+(LocationA(k,1)==0)*4:
                             distance9=20+k*1+width9:NEXT(38$);

38$           ENDWHILE:NEXT(42$);


;
;
;     Model statements for module:  Decide 22
;
42$           BRANCH,        1:
                             If,dock_no==1,1216$,Yes:
                             Else,1217$,Yes;
1216$         ASSIGN:        Decide 22.NumberOut True=Decide 22.NumberOut True + 1:NEXT(40$);

1217$         ASSIGN:        Decide 22.NumberOut False=Decide 22.NumberOut False + 1:NEXT(50$);


;
;
;     Model statements for module:  Seize 9
;
40$           QUEUE,         Seizing a forklift from forklift set at shipment ramp1.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet3,CYC, trans_no3),1:NEXT(1219$);

1219$         DELAY:         0.0,,VA:NEXT(537$);


;
;
;     Model statements for module:  Decide 233
;
537$          BRANCH,        1:
                             If,departure from stock exceeded<>1,1220$,Yes:
                             Else,1221$,Yes;
1220$         ASSIGN:        Decide 233.NumberOut True=Decide 233.NumberOut True + 1:NEXT(43$);

1221$         ASSIGN:        Decide 233.NumberOut False=Decide 233.NumberOut False + 1:NEXT(538$);


;
;
;     Model statements for module:  Delay 5
;
43$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance9)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance11)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance13)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance15)+NORM(0,7.3))*2)),,
                             Other:NEXT(93$);

93$           RELEASE:       Member(TransSet3, trans_no3),1;
494$          ASSIGN:        #product from d1=#product from d1+1:NEXT(189$);


;
;
;     Model statements for module:  Decide 123
;
189$          BRANCH,        1:
                             If,#product from d1==8,1222$,Yes:
                             Else,1223$,Yes;
1222$         ASSIGN:        Decide 123.NumberOut True=Decide 123.NumberOut True + 1:NEXT(225$);

1223$         ASSIGN:        Decide 123.NumberOut False=Decide 123.NumberOut False + 1:NEXT(502$);

225$          TALLY:         time for pickup to d1,tnow-leave the dock1 queue,1;
495$          ASSIGN:        #product from d1=#product from d1-#product from d1:NEXT(545$);


;
;
;     Model statements for module:  Decide 238
;
545$          BRANCH,        1:
                             If,((STATE(Trans3)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),86$,Yes:
                             If,((STATE(Trans2)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),86$,Yes:
                             If,((STATE(Trans1)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),548$,Yes:
                             Else,546$,Yes;

;
;
;     Model statements for module:  Process 80
;
546$          ASSIGN:        Loading from dock1_2.NumberIn=Loading from dock1_2.NumberIn + 1:
                             Loading from dock1_2.WIP=Loading from dock1_2.WIP+1;
1255$         STACK,         1:Save:NEXT(1229$);

1229$         QUEUE,         Loading from dock1_2.Queue;
1228$         SEIZE,         1,VA:
                             SELECT(TransSet4,SNB, ),1:NEXT(1227$);

1227$         DELAY:         SecondsToBaseTime(UNIF(62,83,63)),,VA:NEXT(1270$);

1270$         ASSIGN:        Loading from dock1_2.WaitTime=Loading from dock1_2.WaitTime + Diff.WaitTime;
1234$         TALLY:         Loading from dock1_2.WaitTimePerEntity,Diff.WaitTime,1;
1236$         TALLY:         Loading from dock1_2.TotalTimePerEntity,Diff.StartTime,1;
1260$         ASSIGN:        Loading from dock1_2.VATime=Loading from dock1_2.VATime + Diff.VATime;
1261$         TALLY:         Loading from dock1_2.VATimePerEntity,Diff.VATime,1;
1226$         RELEASE:       SELECT(TransSet4,LAST),1;
1275$         STACK,         1:Destroy:NEXT(1274$);

1274$         ASSIGN:        Loading from dock1_2.NumberOut=Loading from dock1_2.NumberOut + 1:
                             Loading from dock1_2.WIP=Loading from dock1_2.WIP-1:NEXT(215$);

215$          ASSIGN:        #loaded1=#loaded1+1:NEXT(46$);


;
;
;     Model statements for module:  Decide 38
;
46$           BRANCH,        1:
                             If,#loaded1==ordersize,1277$,Yes:
                             Else,1278$,Yes;
1277$         ASSIGN:        Decide 38.NumberOut True=Decide 38.NumberOut True + 1:NEXT(44$);

1278$         ASSIGN:        Decide 38.NumberOut False=Decide 38.NumberOut False + 1:NEXT(45$);


;
;
;     Model statements for module:  Release 13
;
44$           RELEASE:       dock1,1:NEXT(216$);

216$          ASSIGN:        #loaded1=#loaded1-#loaded1;
227$          TALLY:         time in system from d1 for shipment,tnow-shipmentqenter,1;
293$          COUNT:         # of trucks that are in system  more than 60 minutes from d1,(tnow-shipmentqenter)>60;
489$          COUNT:         # of trucks that are in system  more than 45 minutes from d1,(tnow-shipmentqenter)>45;
294$          COUNT:         #of trucks that are from d1,1;
492$          TALLY:         time for loading at d1,tnow-starting time of loading at d1,1:NEXT(45$);


;
;
;     Model statements for module:  Dispose 13
;
45$           ASSIGN:        Dispose 13.NumberOut=Dispose 13.NumberOut + 1;
1279$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Process 5
;
86$           ASSIGN:        Loading from dock1.NumberIn=Loading from dock1.NumberIn + 1:
                             Loading from dock1.WIP=Loading from dock1.WIP+1;
1309$         STACK,         1:Save:NEXT(1283$);

1283$         QUEUE,         Loading from dock1.Queue;
1282$         SEIZE,         1,VA:
                             SELECT(TransSeta,SNB, ),1:NEXT(1281$);

1281$         DELAY:         SecondsToBaseTime(UNIF(62,83,63)),,VA:NEXT(1324$);

1324$         ASSIGN:        Loading from dock1.WaitTime=Loading from dock1.WaitTime + Diff.WaitTime;
1288$         TALLY:         Loading from dock1.WaitTimePerEntity,Diff.WaitTime,1;
1290$         TALLY:         Loading from dock1.TotalTimePerEntity,Diff.StartTime,1;
1314$         ASSIGN:        Loading from dock1.VATime=Loading from dock1.VATime + Diff.VATime;
1315$         TALLY:         Loading from dock1.VATimePerEntity,Diff.VATime,1;
1280$         RELEASE:       SELECT(TransSeta,LAST),1;
1329$         STACK,         1:Destroy:NEXT(1328$);

1328$         ASSIGN:        Loading from dock1.NumberOut=Loading from dock1.NumberOut + 1:
                             Loading from dock1.WIP=Loading from dock1.WIP-1:NEXT(215$);


;
;
;     Model statements for module:  Process 83
;
548$          ASSIGN:        Loading from dock1_1.NumberIn=Loading from dock1_1.NumberIn + 1:
                             Loading from dock1_1.WIP=Loading from dock1_1.WIP+1;
1360$         STACK,         1:Save:NEXT(1334$);

1334$         QUEUE,         Loading from dock1_1.Queue;
1333$         SEIZE,         1,VA:
                             SELECT(TransSetb,SNB, ),1:NEXT(1332$);

1332$         DELAY:         SecondsToBaseTime(UNIF(62,83,63)),,VA:NEXT(1375$);

1375$         ASSIGN:        Loading from dock1_1.WaitTime=Loading from dock1_1.WaitTime + Diff.WaitTime;
1339$         TALLY:         Loading from dock1_1.WaitTimePerEntity,Diff.WaitTime,1;
1341$         TALLY:         Loading from dock1_1.TotalTimePerEntity,Diff.StartTime,1;
1365$         ASSIGN:        Loading from dock1_1.VATime=Loading from dock1_1.VATime + Diff.VATime;
1366$         TALLY:         Loading from dock1_1.VATimePerEntity,Diff.VATime,1;
1331$         RELEASE:       SELECT(TransSetb,LAST),1;
1380$         STACK,         1:Destroy:NEXT(1379$);

1379$         ASSIGN:        Loading from dock1_1.NumberOut=Loading from dock1_1.NumberOut + 1:
                             Loading from dock1_1.WIP=Loading from dock1_1.WIP-1:NEXT(215$);

502$          ASSIGN:        #product being loaded from d1=#product being loaded from d1+1:NEXT(504$);


;
;
;     Model statements for module:  Decide 219
;
504$          BRANCH,        1:
                             If,#product being loaded from d1==1,1382$,Yes:
                             Else,1383$,Yes;
1382$         ASSIGN:        Decide 219.NumberOut True=Decide 219.NumberOut True + 1:NEXT(503$);

1383$         ASSIGN:        Decide 219.NumberOut False=Decide 219.NumberOut False + 1:NEXT(505$);


;
;
;     Model statements for module:  Assign 177
;
503$          ASSIGN:        starting time of loading at d1=tnow:NEXT(545$);


;
;
;     Model statements for module:  Decide 220
;
505$          BRANCH,        1:
                             If,#product being loaded from d1==7,1384$,Yes:
                             Else,1385$,Yes;
1384$         ASSIGN:        Decide 220.NumberOut True=Decide 220.NumberOut True + 1:NEXT(506$);

1385$         ASSIGN:        Decide 220.NumberOut False=Decide 220.NumberOut False + 1:NEXT(545$);

506$          ASSIGN:        #product being loaded from d1=#product being loaded from d1-#product being loaded from d1
                             :NEXT(545$);


;
;
;     Model statements for module:  Delay 17
;
538$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(93$);


;
;
;     Model statements for module:  Seize 12
;
50$           QUEUE,         Seizing a forklift from forklift set at shipment ramp2.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet6,CYC, trans_no6),1:NEXT(1387$);

1387$         DELAY:         0.0,,VA:NEXT(539$);


;
;
;     Model statements for module:  Decide 234
;
539$          BRANCH,        1:
                             If,departure from stock exceeded<>1,1388$,Yes:
                             Else,1389$,Yes;
1388$         ASSIGN:        Decide 234.NumberOut True=Decide 234.NumberOut True + 1:NEXT(52$);

1389$         ASSIGN:        Decide 234.NumberOut False=Decide 234.NumberOut False + 1:NEXT(540$);


;
;
;     Model statements for module:  Delay 8
;
52$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance10)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance12)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance14)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance16)+NORM(0,7.3))*2)),,
                             Other:NEXT(53$);

53$           RELEASE:       Member(TransSet6, Trans_No6),1;
496$          ASSIGN:        #product from d2=#product from d2+1:NEXT(188$);


;
;
;     Model statements for module:  Decide 122
;
188$          BRANCH,        1:
                             If,#product from d2==8,1390$,Yes:
                             Else,1391$,Yes;
1390$         ASSIGN:        Decide 122.NumberOut True=Decide 122.NumberOut True + 1:NEXT(226$);

1391$         ASSIGN:        Decide 122.NumberOut False=Decide 122.NumberOut False + 1:NEXT(498$);

226$          TALLY:         time for pickup to d2,tnow-leave the dock2 queue,1;
497$          ASSIGN:        #product from d2=#product from d2-#product from d2:NEXT(549$);


;
;
;     Model statements for module:  Decide 240
;
549$          BRANCH,        1:
                             If,((STATE(Trans3)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),77$,Yes:
                             If,((STATE(Trans2)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),550$,Yes:
                             If,((STATE(Trans1)==INACTIVE_RES)&&(STATE(Trans5)==INACTIVE_RES)),550$,Yes:
                             Else,547$,Yes;

;
;
;     Model statements for module:  Process 81
;
547$          ASSIGN:        Loading from dock2_2.NumberIn=Loading from dock2_2.NumberIn + 1:
                             Loading from dock2_2.WIP=Loading from dock2_2.WIP+1;
1423$         STACK,         1:Save:NEXT(1397$);

1397$         QUEUE,         Loading from dock2_2.Queue;
1396$         SEIZE,         1,VA:
                             SELECT(TransSet5,SNB, ),1:NEXT(1395$);

1395$         DELAY:         SecondsToBaseTime(UNIF(62,83,64)),,VA:NEXT(1438$);

1438$         ASSIGN:        Loading from dock2_2.WaitTime=Loading from dock2_2.WaitTime + Diff.WaitTime;
1402$         TALLY:         Loading from dock2_2.WaitTimePerEntity,Diff.WaitTime,1;
1404$         TALLY:         Loading from dock2_2.TotalTimePerEntity,Diff.StartTime,1;
1428$         ASSIGN:        Loading from dock2_2.VATime=Loading from dock2_2.VATime + Diff.VATime;
1429$         TALLY:         Loading from dock2_2.VATimePerEntity,Diff.VATime,1;
1394$         RELEASE:       SELECT(TransSet5,LAST),1;
1443$         STACK,         1:Destroy:NEXT(1442$);

1442$         ASSIGN:        Loading from dock2_2.NumberOut=Loading from dock2_2.NumberOut + 1:
                             Loading from dock2_2.WIP=Loading from dock2_2.WIP-1:NEXT(217$);

217$          ASSIGN:        #loaded2=#loaded2+1:NEXT(47$);


;
;
;     Model statements for module:  Decide 39
;
47$           BRANCH,        1:
                             If,#loaded2==ordersize,1445$,Yes:
                             Else,1446$,Yes;
1445$         ASSIGN:        Decide 39.NumberOut True=Decide 39.NumberOut True + 1:NEXT(48$);

1446$         ASSIGN:        Decide 39.NumberOut False=Decide 39.NumberOut False + 1:NEXT(49$);


;
;
;     Model statements for module:  Release 14
;
48$           RELEASE:       dock2,1:NEXT(218$);

218$          ASSIGN:        #loaded2=#loaded2-#loaded2;
228$          TALLY:         time in system from d2 for shipment,tnow-shipmentqenter,1;
295$          COUNT:         # of trucks that are in system  more than 60 minutes from d2,(tnow-shipmentqenter)>60;
490$          COUNT:         # of trucks that are in system  more than 45 minutes from d2,(tnow-shipmentqenter)>45;
296$          COUNT:         #of trucks that are from d2,1;
493$          TALLY:         time for loading at d2,tnow-starting time of loading at d2,1:NEXT(49$);


;
;
;     Model statements for module:  Dispose 14
;
49$           ASSIGN:        Dispose 14.NumberOut=Dispose 14.NumberOut + 1;
1447$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Process 4
;
77$           ASSIGN:        Loading from dock2.NumberIn=Loading from dock2.NumberIn + 1:
                             Loading from dock2.WIP=Loading from dock2.WIP+1;
1477$         STACK,         1:Save:NEXT(1451$);

1451$         QUEUE,         Loading from dock2.Queue;
1450$         SEIZE,         1,VA:
                             SELECT(TransSetb,SNB, ),1:NEXT(1449$);

1449$         DELAY:         SecondsToBaseTime(UNIF(62,83,64)),,VA:NEXT(1492$);

1492$         ASSIGN:        Loading from dock2.WaitTime=Loading from dock2.WaitTime + Diff.WaitTime;
1456$         TALLY:         Loading from dock2.WaitTimePerEntity,Diff.WaitTime,1;
1458$         TALLY:         Loading from dock2.TotalTimePerEntity,Diff.StartTime,1;
1482$         ASSIGN:        Loading from dock2.VATime=Loading from dock2.VATime + Diff.VATime;
1483$         TALLY:         Loading from dock2.VATimePerEntity,Diff.VATime,1;
1448$         RELEASE:       SELECT(TransSetb,LAST),1;
1497$         STACK,         1:Destroy:NEXT(1496$);

1496$         ASSIGN:        Loading from dock2.NumberOut=Loading from dock2.NumberOut + 1:
                             Loading from dock2.WIP=Loading from dock2.WIP-1:NEXT(217$);


;
;
;     Model statements for module:  Process 84
;
550$          ASSIGN:        Loading from dock2_1.NumberIn=Loading from dock2_1.NumberIn + 1:
                             Loading from dock2_1.WIP=Loading from dock2_1.WIP+1;
1528$         STACK,         1:Save:NEXT(1502$);

1502$         QUEUE,         Loading from dock2_1.Queue;
1501$         SEIZE,         1,VA:
                             SELECT(TransSetc,SNB, ),1:NEXT(1500$);

1500$         DELAY:         SecondsToBaseTime(UNIF(62,83,64)),,VA:NEXT(1543$);

1543$         ASSIGN:        Loading from dock2_1.WaitTime=Loading from dock2_1.WaitTime + Diff.WaitTime;
1507$         TALLY:         Loading from dock2_1.WaitTimePerEntity,Diff.WaitTime,1;
1509$         TALLY:         Loading from dock2_1.TotalTimePerEntity,Diff.StartTime,1;
1533$         ASSIGN:        Loading from dock2_1.VATime=Loading from dock2_1.VATime + Diff.VATime;
1534$         TALLY:         Loading from dock2_1.VATimePerEntity,Diff.VATime,1;
1499$         RELEASE:       SELECT(TransSetc,LAST),1;
1548$         STACK,         1:Destroy:NEXT(1547$);

1547$         ASSIGN:        Loading from dock2_1.NumberOut=Loading from dock2_1.NumberOut + 1:
                             Loading from dock2_1.WIP=Loading from dock2_1.WIP-1:NEXT(217$);

498$          ASSIGN:        #product being loaded from d2=#product being loaded from d2+1:NEXT(499$);


;
;
;     Model statements for module:  Decide 217
;
499$          BRANCH,        1:
                             If,#product being loaded from d2==1,1550$,Yes:
                             Else,1551$,Yes;
1550$         ASSIGN:        Decide 217.NumberOut True=Decide 217.NumberOut True + 1:NEXT(491$);

1551$         ASSIGN:        Decide 217.NumberOut False=Decide 217.NumberOut False + 1:NEXT(500$);


;
;
;     Model statements for module:  Assign 176
;
491$          ASSIGN:        starting time of loading at d2=tnow:NEXT(549$);


;
;
;     Model statements for module:  Decide 218
;
500$          BRANCH,        1:
                             If,#product being loaded from d2==7,1552$,Yes:
                             Else,1553$,Yes;
1552$         ASSIGN:        Decide 218.NumberOut True=Decide 218.NumberOut True + 1:NEXT(501$);

1553$         ASSIGN:        Decide 218.NumberOut False=Decide 218.NumberOut False + 1:NEXT(549$);

501$          ASSIGN:        #product being loaded from d2=#product being loaded from d2-#product being loaded from d2
                             :NEXT(549$);


;
;
;     Model statements for module:  Delay 21
;
540$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(53$);


;
;
;     Model statements for module:  Assign 44
;
65$           ASSIGN:        width10=
                             (LocationA(k,1)==4)*0+(LocationA(k,1)==3)*1+(LocationA(k,1)==2)*2+(LocationA(k,1)==1)*3+(LocationA(k,1)==0)*4:
                             distance10=23+k*1+width10:NEXT(38$);


;
;
;     Model statements for module:  Decide 19
;
33$           BRANCH,        1:
                             If,( LocationB(k,1) <> 0 )  &&  ( type == LocationB(k,2) ),1554$,Yes:
                             Else,1555$,Yes;
1554$         ASSIGN:        Decide 19.NumberOut True=Decide 19.NumberOut True + 1:NEXT(34$);

1555$         ASSIGN:        Decide 19.NumberOut False=Decide 19.NumberOut False + 1:NEXT(78$);

34$           ASSIGN:        LocationB(k,1)=LocationB(k,1)-1:NEXT(35$);


;
;
;     Model statements for module:  Assign 30
;
35$           ASSIGN:        picked=1:
                             Locationtype=2:NEXT(36$);


;
;
;     Model statements for module:  Decide 21
;
36$           BRANCH,        1:
                             If,LocationB(k,1)==0,1556$,Yes:
                             Else,1557$,Yes;
1556$         ASSIGN:        Decide 21.NumberOut True=Decide 21.NumberOut True + 1:NEXT(37$);

1557$         ASSIGN:        Decide 21.NumberOut False=Decide 21.NumberOut False + 1:NEXT(515$);

37$           ASSIGN:        LocationB(k,2)=0:NEXT(515$);


;
;
;     Model statements for module:  Decide 225
;
515$          BRANCH,        1:
                             If,dock_no==1,1558$,Yes:
                             Else,1559$,Yes;
1558$         ASSIGN:        Decide 225.NumberOut True=Decide 225.NumberOut True + 1:NEXT(516$);

1559$         ASSIGN:        Decide 225.NumberOut False=Decide 225.NumberOut False + 1:NEXT(517$);


;
;
;     Model statements for module:  Assign 191
;
516$          ASSIGN:        width11=
                             (LocationB(k,1)==4)*0+(LocationB(k,1)==3)*1+(LocationB(k,1)==2)*2+(LocationB(k,1)==1)*3+(LocationB(k,1)==0)*4:
                             distance11=20+k*1+width11:NEXT(38$);


;
;
;     Model statements for module:  Assign 192
;
517$          ASSIGN:        width12=
                             (LocationB(k,1)==4)*0+(LocationB(k,1)==3)*1+(LocationB(k,1)==2)*2+(LocationB(k,1)==1)*3+(LocationB(k,1)==0)*4:
                             distance12=23+k*1+width12:NEXT(38$);


;
;
;     Model statements for module:  Decide 82
;
78$           BRANCH,        1:
                             If,( LocationC(k,1) <> 0 )  &&  ( type == LocationC(k,2) ),1560$,Yes:
                             Else,1561$,Yes;
1560$         ASSIGN:        Decide 82.NumberOut True=Decide 82.NumberOut True + 1:NEXT(79$);

1561$         ASSIGN:        Decide 82.NumberOut False=Decide 82.NumberOut False + 1:NEXT(153$);

79$           ASSIGN:        LocationC(k,1)=LocationC(k,1)-1:NEXT(80$);


;
;
;     Model statements for module:  Assign 53
;
80$           ASSIGN:        picked=1:
                             Locationtype=3:NEXT(81$);


;
;
;     Model statements for module:  Decide 83
;
81$           BRANCH,        1:
                             If,LocationC(k,1)==0,1562$,Yes:
                             Else,1563$,Yes;
1562$         ASSIGN:        Decide 83.NumberOut True=Decide 83.NumberOut True + 1:NEXT(82$);

1563$         ASSIGN:        Decide 83.NumberOut False=Decide 83.NumberOut False + 1:NEXT(83$);

82$           ASSIGN:        LocationC(k,2)=0:NEXT(83$);


;
;
;     Model statements for module:  Decide 84
;
83$           BRANCH,        1:
                             If,dock_no==1,1564$,Yes:
                             Else,1565$,Yes;
1564$         ASSIGN:        Decide 84.NumberOut True=Decide 84.NumberOut True + 1:NEXT(84$);

1565$         ASSIGN:        Decide 84.NumberOut False=Decide 84.NumberOut False + 1:NEXT(85$);


;
;
;     Model statements for module:  Assign 55
;
84$           ASSIGN:        width13=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance13=13+k*1+width13:NEXT(38$);


;
;
;     Model statements for module:  Assign 56
;
85$           ASSIGN:        width14=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance14=14+k*1+width14:NEXT(38$);


;
;
;     Model statements for module:  Decide 111
;
153$          BRANCH,        1:
                             If,( LocationD(k,1) <> 0 )  &&  ( type == LocationD(k,2) ),1566$,Yes:
                             Else,1567$,Yes;
1566$         ASSIGN:        Decide 111.NumberOut True=Decide 111.NumberOut True + 1:NEXT(154$);

1567$         ASSIGN:        Decide 111.NumberOut False=Decide 111.NumberOut False + 1:NEXT(39$);

154$          ASSIGN:        LocationD(k,1)=LocationD(k,1)-1:NEXT(155$);


;
;
;     Model statements for module:  Assign 77
;
155$          ASSIGN:        picked=1:
                             Locationtype=4:NEXT(156$);


;
;
;     Model statements for module:  Decide 112
;
156$          BRANCH,        1:
                             If,LocationD(k,1)==0,1568$,Yes:
                             Else,1569$,Yes;
1568$         ASSIGN:        Decide 112.NumberOut True=Decide 112.NumberOut True + 1:NEXT(157$);

1569$         ASSIGN:        Decide 112.NumberOut False=Decide 112.NumberOut False + 1:NEXT(518$);

157$          ASSIGN:        LocationD(k,2)=0:NEXT(518$);


;
;
;     Model statements for module:  Decide 226
;
518$          BRANCH,        1:
                             If,dock_no==1,1570$,Yes:
                             Else,1571$,Yes;
1570$         ASSIGN:        Decide 226.NumberOut True=Decide 226.NumberOut True + 1:NEXT(519$);

1571$         ASSIGN:        Decide 226.NumberOut False=Decide 226.NumberOut False + 1:NEXT(520$);


;
;
;     Model statements for module:  Assign 193
;
519$          ASSIGN:        width15=
                             (LocationD(k,1)==7)*0+(LocationD(k,1)==6)*1+(LocationD(k,1)==5)*2+(LocationD(k,1)==4)*3+(LocationD(k,1)==3)*4+(LocationD(k,1)==2)*5+(LocationD(k,1)==1)*6+(LocationD(k,1)==0)*7:
                             distance15=13+k*1+width15:NEXT(38$);


;
;
;     Model statements for module:  Assign 194
;
520$          ASSIGN:        width16=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance16=14+k*1+width16:NEXT(38$);


;
;
;     Model statements for module:  Assign 32
;
39$           ASSIGN:        k=k+1:NEXT(531$);


;
;
;     Model statements for module:  Decide 231
;
531$          BRANCH,        1:
                             If,k<=231,1572$,Yes:
                             Else,1573$,Yes;
1572$         ASSIGN:        Decide 231.NumberOut True=Decide 231.NumberOut True + 1:NEXT(38$);

1573$         ASSIGN:        Decide 231.NumberOut False=Decide 231.NumberOut False + 1:NEXT(536$);


;
;
;     Model statements for module:  Assign 197
;
536$          ASSIGN:        departure from stock exceeded=1:NEXT(532$);


;
;
;     Model statements for module:  Decide 232
;
532$          BRANCH,        1:
                             If,type==1,533$,Yes:
                             If,type==2,534$,Yes:
                             Else,535$,Yes;
535$          ASSIGN:        stock3=stock3-1:NEXT(42$);

533$          ASSIGN:        stock1=stock1-1:NEXT(42$);

534$          ASSIGN:        stock2=stock2-1:NEXT(42$);

298$          TALLY:         time in shipmentq at d2,tnow-shipmentqenter,1:NEXT(67$);


;
;
;     Model statements for module:  Assign 48
;
67$           ASSIGN:        dock_no=2:
                             leave the dock2 queue=tnow:NEXT(26$);


;
;
;     Model statements for module:  Record 32
;
160$          COUNT:         #runaway,1:NEXT(159$);


;
;
;     Model statements for module:  Dispose 21
;
159$          ASSIGN:        Dispose 21.NumberOut=Dispose 21.NumberOut + 1;
1576$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Decide 118
;
168$          BRANCH,        1:
                             If,product1stock>=safety stock,1577$,Yes:
                             Else,1578$,Yes;
1577$         ASSIGN:        Decide 118.NumberOut True=Decide 118.NumberOut True + 1:NEXT(219$);

1578$         ASSIGN:        Decide 118.NumberOut False=Decide 118.NumberOut False + 1:NEXT(160$);

219$          COUNT:         dispatchatruck,1:NEXT(24$);


;
;
;     Model statements for module:  Decide 119
;
169$          BRANCH,        1:
                             If,product2stock>=safety stock,1579$,Yes:
                             Else,1580$,Yes;
1579$         ASSIGN:        Decide 119.NumberOut True=Decide 119.NumberOut True + 1:NEXT(220$);

1580$         ASSIGN:        Decide 119.NumberOut False=Decide 119.NumberOut False + 1:NEXT(160$);

220$          COUNT:         dispatchbtruck,1:NEXT(24$);


;
;
;     Model statements for module:  Dispose 20
;
108$          ASSIGN:        Dispose 20.NumberOut=Dispose 20.NumberOut + 1;
1581$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 73
;
134$          ASSIGN:        departureb2# c1=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,98)
                             :NEXT(138$);


;
;
;     Model statements for module:  Decide 106
;
138$          BRANCH,        1:
                             If,departureb2# c1==0,108$,Yes:
                             If,departureb2# c1==1,139$,Yes:
                             Else,140$,Yes;

;
;
;     Model statements for module:  Separate 10
;
140$          DUPLICATE,     100 - 50:
                             departureb2# c1-1,1586$,50:NEXT(1585$);

1585$         ASSIGN:        Separate 10.NumberOut Orig=Separate 10.NumberOut Orig + 1:NEXT(139$);

1586$         ASSIGN:        Separate 10.NumberOut Dup=Separate 10.NumberOut Dup + 1:NEXT(139$);


;
;
;     Model statements for module:  Process 15
;
139$          ASSIGN:        Process 15.NumberIn=Process 15.NumberIn + 1:
                             Process 15.WIP=Process 15.WIP+1;
1616$         STACK,         1:Save:NEXT(1590$);

1590$         QUEUE,         Process 15.Queue;
1589$         SEIZE,         2,VA:
                             Resource 9,1:NEXT(1588$);

1588$         DELAY:         HoursToBaseTime(expo(14/departureb2# c1,34)),,VA:NEXT(1631$);

1631$         ASSIGN:        Process 15.WaitTime=Process 15.WaitTime + Diff.WaitTime;
1595$         TALLY:         Process 15.WaitTimePerEntity,Diff.WaitTime,1;
1597$         TALLY:         Process 15.TotalTimePerEntity,Diff.StartTime,1;
1621$         ASSIGN:        Process 15.VATime=Process 15.VATime + Diff.VATime;
1622$         TALLY:         Process 15.VATimePerEntity,Diff.VATime,1;
1587$         RELEASE:       Resource 9,1;
1636$         STACK,         1:Destroy:NEXT(1635$);

1635$         ASSIGN:        Process 15.NumberOut=Process 15.NumberOut + 1:
                             Process 15.WIP=Process 15.WIP-1:NEXT(90$);


;
;
;     Model statements for module:  Create 7
;

1638$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c1:MinutesToBaseTime(1440):NEXT(1639$);

1639$         ASSIGN:        Create for shipment c shift1 c1.NumberOut=Create for shipment c shift1 c1.NumberOut + 1:NEXT(141$);


;
;
;     Model statements for module:  Decide 107
;
141$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1642$,Yes:
                             Else,1643$,Yes;
1642$         ASSIGN:        Decide 107.NumberOut True=Decide 107.NumberOut True + 1:NEXT(142$);

1643$         ASSIGN:        Decide 107.NumberOut False=Decide 107.NumberOut False + 1:NEXT(143$);


;
;
;     Model statements for module:  Assign 74
;
142$          ASSIGN:        departurec1# c1=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,99):NEXT(144$);


;
;
;     Model statements for module:  Decide 108
;
144$          BRANCH,        1:
                             If,departurec1# c1==0,108$,Yes:
                             If,departurec1# c1==1,145$,Yes:
                             Else,146$,Yes;

;
;
;     Model statements for module:  Separate 11
;
146$          DUPLICATE,     100 - 50:
                             departurec1# c1-1,1648$,50:NEXT(1647$);

1647$         ASSIGN:        Separate 11.NumberOut Orig=Separate 11.NumberOut Orig + 1:NEXT(145$);

1648$         ASSIGN:        Separate 11.NumberOut Dup=Separate 11.NumberOut Dup + 1:NEXT(145$);


;
;
;     Model statements for module:  Process 16
;
145$          ASSIGN:        Process 16.NumberIn=Process 16.NumberIn + 1:
                             Process 16.WIP=Process 16.WIP+1;
1678$         STACK,         1:Save:NEXT(1652$);

1652$         QUEUE,         Process 16.Queue;
1651$         SEIZE,         2,VA:
                             Resource 10,1:NEXT(1650$);

1650$         DELAY:         HoursToBaseTime(expo(10/departurec1# c1,35)),,VA:NEXT(1693$);

1693$         ASSIGN:        Process 16.WaitTime=Process 16.WaitTime + Diff.WaitTime;
1657$         TALLY:         Process 16.WaitTimePerEntity,Diff.WaitTime,1;
1659$         TALLY:         Process 16.TotalTimePerEntity,Diff.StartTime,1;
1683$         ASSIGN:        Process 16.VATime=Process 16.VATime + Diff.VATime;
1684$         TALLY:         Process 16.VATimePerEntity,Diff.VATime,1;
1649$         RELEASE:       Resource 10,1;
1698$         STACK,         1:Destroy:NEXT(1697$);

1697$         ASSIGN:        Process 16.NumberOut=Process 16.NumberOut + 1:
                             Process 16.WIP=Process 16.WIP-1:NEXT(91$);


;
;
;     Model statements for module:  Assign 61
;
91$           ASSIGN:        type=3:NEXT(158$);


;
;
;     Model statements for module:  Assign 75
;
143$          ASSIGN:        departurec2# c1=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,100):NEXT(147$);


;
;
;     Model statements for module:  Decide 109
;
147$          BRANCH,        1:
                             If,departurec2# c1==0,108$,Yes:
                             If,departurec2# c1==1,148$,Yes:
                             Else,149$,Yes;

;
;
;     Model statements for module:  Separate 12
;
149$          DUPLICATE,     100 - 50:
                             departurec2# c1-1,1704$,50:NEXT(1703$);

1703$         ASSIGN:        Separate 12.NumberOut Orig=Separate 12.NumberOut Orig + 1:NEXT(148$);

1704$         ASSIGN:        Separate 12.NumberOut Dup=Separate 12.NumberOut Dup + 1:NEXT(148$);


;
;
;     Model statements for module:  Process 17
;
148$          ASSIGN:        Process 17.NumberIn=Process 17.NumberIn + 1:
                             Process 17.WIP=Process 17.WIP+1;
1734$         STACK,         1:Save:NEXT(1708$);

1708$         QUEUE,         Process 17.Queue;
1707$         SEIZE,         2,VA:
                             Resource 11,1:NEXT(1706$);

1706$         DELAY:         HoursToBaseTime(expo(14/departurec2# c1,36)),,VA:NEXT(1749$);

1749$         ASSIGN:        Process 17.WaitTime=Process 17.WaitTime + Diff.WaitTime;
1713$         TALLY:         Process 17.WaitTimePerEntity,Diff.WaitTime,1;
1715$         TALLY:         Process 17.TotalTimePerEntity,Diff.StartTime,1;
1739$         ASSIGN:        Process 17.VATime=Process 17.VATime + Diff.VATime;
1740$         TALLY:         Process 17.VATimePerEntity,Diff.VATime,1;
1705$         RELEASE:       Resource 11,1;
1754$         STACK,         1:Destroy:NEXT(1753$);

1753$         ASSIGN:        Process 17.NumberOut=Process 17.NumberOut + 1:
                             Process 17.WIP=Process 17.WIP-1:NEXT(91$);


;
;
;     Model statements for module:  Create 9
;

1756$         CREATE,        1,HoursToBaseTime(0.0),Entity 1:HoursToBaseTime(24):NEXT(1757$);

1757$         ASSIGN:        Create 9.NumberOut=Create 9.NumberOut + 1:NEXT(98$);


;
;
;     Model statements for module:  Assign 64
;
98$           ASSIGN:        day=day+1:NEXT(99$);


;
;
;     Model statements for module:  Dispose 17
;
99$           ASSIGN:        Dispose 17.NumberOut=Dispose 17.NumberOut + 1;
1760$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Create 11
;

1761$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c1:MinutesToBaseTime(1440):NEXT(1762$);

1762$         ASSIGN:        Create for receiving a shift2 c1.NumberOut=Create for receiving a shift2 c1.NumberOut + 1
                             :NEXT(100$);


;
;
;     Model statements for module:  Decide 93
;
100$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1765$,Yes:
                             Else,1766$,Yes;
1765$         ASSIGN:        Decide 93.NumberOut True=Decide 93.NumberOut True + 1:NEXT(92$);

1766$         ASSIGN:        Decide 93.NumberOut False=Decide 93.NumberOut False + 1:NEXT(101$);


;
;
;     Model statements for module:  Assign 62
;
92$           ASSIGN:        receipta1# c1=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,65)
                             :NEXT(94$);


;
;
;     Model statements for module:  Decide 92
;
94$           BRANCH,        1:
                             If,receipta1# c1==0,95$,Yes:
                             If,receipta1# c1==1,96$,Yes:
                             Else,97$,Yes;

;
;
;     Model statements for module:  Separate 1
;
97$           DUPLICATE,     100 - 50:
                             receipta1# c1-1,1771$,50:NEXT(1770$);

1770$         ASSIGN:        Separate 1.NumberOut Orig=Separate 1.NumberOut Orig + 1:NEXT(96$);

1771$         ASSIGN:        Separate 1.NumberOut Dup=Separate 1.NumberOut Dup + 1:NEXT(96$);


;
;
;     Model statements for module:  Process 6
;
96$           ASSIGN:        Process 6.NumberIn=Process 6.NumberIn + 1:
                             Process 6.WIP=Process 6.WIP+1;
1801$         STACK,         1:Save:NEXT(1775$);

1775$         QUEUE,         Process 6.Queue;
1774$         SEIZE,         2,VA:
                             Resource 1,1:NEXT(1773$);

1773$         DELAY:         HoursToBaseTime(expo(10/receipta1# c1,1)),,VA:NEXT(1816$);

1816$         ASSIGN:        Process 6.WaitTime=Process 6.WaitTime + Diff.WaitTime;
1780$         TALLY:         Process 6.WaitTimePerEntity,Diff.WaitTime,1;
1782$         TALLY:         Process 6.TotalTimePerEntity,Diff.StartTime,1;
1806$         ASSIGN:        Process 6.VATime=Process 6.VATime + Diff.VATime;
1807$         TALLY:         Process 6.VATimePerEntity,Diff.VATime,1;
1772$         RELEASE:       Resource 1,1;
1821$         STACK,         1:Destroy:NEXT(1820$);

1820$         ASSIGN:        Process 6.NumberOut=Process 6.NumberOut + 1:
                             Process 6.WIP=Process 6.WIP-1:NEXT(0$);


;
;
;     Model statements for module:  Assign 1
;
0$            ASSIGN:        producttype=1:NEXT(180$);


;
;
;     Model statements for module:  Assign 65
;
101$          ASSIGN:        receipta2# c2=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,66)
                             :NEXT(102$);


;
;
;     Model statements for module:  Decide 94
;
102$          BRANCH,        1:
                             If,receipta2# c1==0,95$,Yes:
                             If,receipta2# c1==1,113$,Yes:
                             Else,103$,Yes;

;
;
;     Model statements for module:  Separate 2
;
103$          DUPLICATE,     100 - 50:
                             receipta2# c1-1,1827$,50:NEXT(1826$);

1826$         ASSIGN:        Separate 2.NumberOut Orig=Separate 2.NumberOut Orig + 1:NEXT(113$);

1827$         ASSIGN:        Separate 2.NumberOut Dup=Separate 2.NumberOut Dup + 1:NEXT(113$);


;
;
;     Model statements for module:  Process 8
;
113$          ASSIGN:        Process 8.NumberIn=Process 8.NumberIn + 1:
                             Process 8.WIP=Process 8.WIP+1;
1857$         STACK,         1:Save:NEXT(1831$);

1831$         QUEUE,         Process 8.Queue;
1830$         SEIZE,         2,VA:
                             Resource 2,1:NEXT(1829$);

1829$         DELAY:         HoursToBaseTime(expo(14/receipta2# c1,2)),,VA:NEXT(1872$);

1872$         ASSIGN:        Process 8.WaitTime=Process 8.WaitTime + Diff.WaitTime;
1836$         TALLY:         Process 8.WaitTimePerEntity,Diff.WaitTime,1;
1838$         TALLY:         Process 8.TotalTimePerEntity,Diff.StartTime,1;
1862$         ASSIGN:        Process 8.VATime=Process 8.VATime + Diff.VATime;
1863$         TALLY:         Process 8.VATimePerEntity,Diff.VATime,1;
1828$         RELEASE:       Resource 2,1;
1877$         STACK,         1:Destroy:NEXT(1876$);

1876$         ASSIGN:        Process 8.NumberOut=Process 8.NumberOut + 1:
                             Process 8.WIP=Process 8.WIP-1:NEXT(0$);


;
;
;     Model statements for module:  Create 15
;

1879$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c1:MinutesToBaseTime(1440):NEXT(1880$);

1880$         ASSIGN:        Create for shipmenta shift2 c1.NumberOut=Create for shipmenta shift2 c1.NumberOut + 1:NEXT(105$);


;
;
;     Model statements for module:  Decide 95
;
105$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1883$,Yes:
                             Else,1884$,Yes;
1883$         ASSIGN:        Decide 95.NumberOut True=Decide 95.NumberOut True + 1:NEXT(104$);

1884$         ASSIGN:        Decide 95.NumberOut False=Decide 95.NumberOut False + 1:NEXT(106$);


;
;
;     Model statements for module:  Assign 66
;
104$          ASSIGN:        departurea1# c1=disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,95)
                             :NEXT(107$);


;
;
;     Model statements for module:  Decide 96
;
107$          BRANCH,        1:
                             If,departurea1# c1==0,108$,Yes:
                             If,departurea1# c1==1,109$,Yes:
                             Else,110$,Yes;

;
;
;     Model statements for module:  Separate 3
;
110$          DUPLICATE,     100 - 50:
                             departurea1# c1-1,1889$,50:NEXT(1888$);

1888$         ASSIGN:        Separate 3.NumberOut Orig=Separate 3.NumberOut Orig + 1:NEXT(109$);

1889$         ASSIGN:        Separate 3.NumberOut Dup=Separate 3.NumberOut Dup + 1:NEXT(109$);


;
;
;     Model statements for module:  Process 7
;
109$          ASSIGN:        Process 7.NumberIn=Process 7.NumberIn + 1:
                             Process 7.WIP=Process 7.WIP+1;
1919$         STACK,         1:Save:NEXT(1893$);

1893$         QUEUE,         Process 7.Queue;
1892$         SEIZE,         2,VA:
                             Resource 3,1:NEXT(1891$);

1891$         DELAY:         HoursToBaseTime(expo(10/departurea1# c1,31)),,VA:NEXT(1934$);

1934$         ASSIGN:        Process 7.WaitTime=Process 7.WaitTime + Diff.WaitTime;
1898$         TALLY:         Process 7.WaitTimePerEntity,Diff.WaitTime,1;
1900$         TALLY:         Process 7.TotalTimePerEntity,Diff.StartTime,1;
1924$         ASSIGN:        Process 7.VATime=Process 7.VATime + Diff.VATime;
1925$         TALLY:         Process 7.VATimePerEntity,Diff.VATime,1;
1890$         RELEASE:       Resource 3,1;
1939$         STACK,         1:Destroy:NEXT(1938$);

1938$         ASSIGN:        Process 7.NumberOut=Process 7.NumberOut + 1:
                             Process 7.WIP=Process 7.WIP-1:NEXT(89$);


;
;
;     Model statements for module:  Assign 59
;
89$           ASSIGN:        type=1:NEXT(158$);


;
;
;     Model statements for module:  Assign 67
;
106$          ASSIGN:        departurea2# c1=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,96):NEXT(111$);


;
;
;     Model statements for module:  Decide 97
;
111$          BRANCH,        1:
                             If,departurea2# c1==0,108$,Yes:
                             If,departurea2# c1==1,114$,Yes:
                             Else,112$,Yes;

;
;
;     Model statements for module:  Separate 4
;
112$          DUPLICATE,     100 - 50:
                             departurea2# c1-1,1945$,50:NEXT(1944$);

1944$         ASSIGN:        Separate 4.NumberOut Orig=Separate 4.NumberOut Orig + 1:NEXT(114$);

1945$         ASSIGN:        Separate 4.NumberOut Dup=Separate 4.NumberOut Dup + 1:NEXT(114$);


;
;
;     Model statements for module:  Process 9
;
114$          ASSIGN:        Process 9.NumberIn=Process 9.NumberIn + 1:
                             Process 9.WIP=Process 9.WIP+1;
1975$         STACK,         1:Save:NEXT(1949$);

1949$         QUEUE,         Process 9.Queue;
1948$         SEIZE,         2,VA:
                             Resource 4,1:NEXT(1947$);

1947$         DELAY:         HoursToBaseTime(expo(14/departurea2# c1,32)),,VA:NEXT(1990$);

1990$         ASSIGN:        Process 9.WaitTime=Process 9.WaitTime + Diff.WaitTime;
1954$         TALLY:         Process 9.WaitTimePerEntity,Diff.WaitTime,1;
1956$         TALLY:         Process 9.TotalTimePerEntity,Diff.StartTime,1;
1980$         ASSIGN:        Process 9.VATime=Process 9.VATime + Diff.VATime;
1981$         TALLY:         Process 9.VATimePerEntity,Diff.VATime,1;
1946$         RELEASE:       Resource 4,1;
1995$         STACK,         1:Destroy:NEXT(1994$);

1994$         ASSIGN:        Process 9.NumberOut=Process 9.NumberOut + 1:
                             Process 9.WIP=Process 9.WIP-1:NEXT(89$);


;
;
;     Model statements for module:  Create 16
;

1997$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c1:MinutesToBaseTime(1440):NEXT(1998$);

1998$         ASSIGN:        Create for receiving b shift2 c1.NumberOut=Create for receiving b shift2 c1.NumberOut + 1
                             :NEXT(115$);


;
;
;     Model statements for module:  Create 17
;

2001$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c1:MinutesToBaseTime(1440):NEXT(2002$);

2002$         ASSIGN:        Create for receiving c shift2 c1.NumberOut=Create for receiving c shift2 c1.NumberOut + 1
                             :NEXT(123$);


;
;
;     Model statements for module:  Create 19
;

2005$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c1:MinutesToBaseTime(1440):NEXT(2006$);

2006$         ASSIGN:        Create for shipment b shift2 c1.NumberOut=Create for shipment b shift2 c1.NumberOut + 1:NEXT(132$);


176$          CREATE,        1,TFIN:,1:NEXT(177$);

177$          WRITE,         rqueueoutput:
                             
                             tavg(time in receiptq at d1),tavg(time in receiptq at d2),davg(statistic 1),davg(statistic 2),davg(statistic 3),dmax(statistic 1), dmax(statistic 2),dmax(statistic 3),davg(statistic 4),davg(statistic 5),davg(statistic 6),dmax(statistic 4),dmax(statistic 5),dmax(statistic 6),davg(statistic 7),dmax(statistic 7),davg(statistic 8),dmax(statistic 8);
178$          DISPOSE:       No;


185$          CREATE,        1,TFIN:,1:NEXT(186$);

186$          WRITE,         rtimeinsystem:
                             
                             tavg(time in system from d1), tavg(time in system from d2),tavg(time for putaway from d1),tavg(time for putaway from d2);
187$          DISPOSE:       No;


190$          CREATE,        1,TFIN::NEXT(191$);

191$          WRITE,         utilizationf1:
                             FSTAND(forklift1,1),FSTAND(forklift1,2),FSTAND(forklift1,4);
192$          DISPOSE:       No;


193$          CREATE,        1,TFIN::NEXT(194$);

194$          WRITE,         utilizationf2:
                             FSTAND(forklift2,1),FSTAND(forklift2,2),FSTAND(forklift2,4);
195$          DISPOSE:       No;


196$          CREATE,        1,TFIN::NEXT(197$);

197$          WRITE,         utilizationf3:
                             FSTAND(forklift3,1),FSTAND(forklift3,2),FSTAND(forklift3,4);
198$          DISPOSE:       No;


199$          CREATE,        1,TFIN::NEXT(200$);

200$          WRITE,         utilizationf5:
                             FSTAND(forklift5,1),FSTAND(forklift5,2),FSTAND(forklift5,4);
201$          DISPOSE:       No;


202$          CREATE,        1,TFIN::NEXT(203$);

203$          WRITE,         utilizationf6:
                             FSTAND(forklift6,1),FSTAND(forklift6,2),FSTAND(forklift6,4);
204$          DISPOSE:       No;


205$          CREATE,        1,TFIN::NEXT(206$);

206$          WRITE,         utilizationd1:
                             FSTAND(dock 1,1),FSTAND(dock 1,2),FSTAND(dock 1,4);
207$          DISPOSE:       No;


208$          CREATE,        1,TFIN::NEXT(209$);

209$          WRITE,         utilizationd2:
                             FSTAND(dock 2,1),FSTAND(dock 2,2),FSTAND(dock 2,4);
210$          DISPOSE:       No;


222$          CREATE,        1,TFIN:,1:NEXT(223$);

223$          WRITE,         squeueoutput:
                             
                             tavg(time in shipmentq at d1),tavg(time in shipmentq at d2),nc(dispatchatruck),nc(dispatchbtruck),nc(dispatchctruck),nc(#runaway),tavg(time for pickup to d1),tavg(time for pickup to d2),tavg(time for loading at d1),tavg(time for loading at d2);
224$          DISPOSE:       No;


229$          CREATE,        1,TFIN:,1:NEXT(230$);

230$          WRITE,         stimeinsystem:
                             
                             tavg(time in system from d1 for shipment),nc(# of trucks that are in system  more than 60 minutes from d1),nc(#of trucks that are from d1),tavg(time in system from d2 for shipment),nc(# of trucks that are in system  more than 60 minutes from d2),nc(#of trucks that are from d2),nc(# of trucks that are in system  more than 45 minutes from d1),nc(# of trucks that are in system  more than 45 minutes from d2);
231$          DISPOSE:       No;


;
;
;     Model statements for module:  Create 24
;

2009$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c2:MinutesToBaseTime(1440):NEXT(2010$);

2010$         ASSIGN:        Create for receiving b shift1 c2.NumberOut=Create for receiving b shift1 c2.NumberOut + 1
                             :NEXT(245$);


;
;
;     Model statements for module:  Decide 127
;
245$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2013$,Yes:
                             Else,2014$,Yes;
2013$         ASSIGN:        Decide 127.NumberOut True=Decide 127.NumberOut True + 1:NEXT(542$);

2014$         ASSIGN:        Decide 127.NumberOut False=Decide 127.NumberOut False + 1:NEXT(246$);


;
;
;     Model statements for module:  Assign 199
;
542$          ASSIGN:        receiptb1# c2=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,73)
                             :NEXT(247$);


;
;
;     Model statements for module:  Decide 128
;
247$          BRANCH,        1:
                             If,receiptb1# c2==0,237$,Yes:
                             If,receiptb1# c2==1,248$,Yes:
                             Else,249$,Yes;

;
;
;     Model statements for module:  Separate 15
;
249$          DUPLICATE,     100 - 50:
                             receiptb1# c2-1,2019$,50:NEXT(2018$);

2018$         ASSIGN:        Separate 15.NumberOut Orig=Separate 15.NumberOut Orig + 1:NEXT(248$);

2019$         ASSIGN:        Separate 15.NumberOut Dup=Separate 15.NumberOut Dup + 1:NEXT(248$);


;
;
;     Model statements for module:  Process 20
;
248$          ASSIGN:        Process 20.NumberIn=Process 20.NumberIn + 1:
                             Process 20.WIP=Process 20.WIP+1;
2049$         STACK,         1:Save:NEXT(2023$);

2023$         QUEUE,         Process 20.Queue;
2022$         SEIZE,         2,VA:
                             Resource 14,1:NEXT(2021$);

2021$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c2,9)),,VA:NEXT(2064$);

2064$         ASSIGN:        Process 20.WaitTime=Process 20.WaitTime + Diff.WaitTime;
2028$         TALLY:         Process 20.WaitTimePerEntity,Diff.WaitTime,1;
2030$         TALLY:         Process 20.TotalTimePerEntity,Diff.StartTime,1;
2054$         ASSIGN:        Process 20.VATime=Process 20.VATime + Diff.VATime;
2055$         TALLY:         Process 20.VATimePerEntity,Diff.VATime,1;
2020$         RELEASE:       Resource 14,1;
2069$         STACK,         1:Destroy:NEXT(2068$);

2068$         ASSIGN:        Process 20.NumberOut=Process 20.NumberOut + 1:
                             Process 20.WIP=Process 20.WIP-1:NEXT(233$);


;
;
;     Model statements for module:  Assign 83
;
233$          ASSIGN:        producttype=2:NEXT(180$);


;
;
;     Model statements for module:  Dispose 22
;
237$          ASSIGN:        Dispose 22.NumberOut=Dispose 22.NumberOut + 1;
2071$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 88
;
246$          ASSIGN:        receiptb2# c2=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,74)
                             :NEXT(250$);


;
;
;     Model statements for module:  Decide 129
;
250$          BRANCH,        1:
                             If,receiptb2# c2==0,237$,Yes:
                             If,receiptb2# c2==1,251$,Yes:
                             Else,252$,Yes;

;
;
;     Model statements for module:  Separate 16
;
252$          DUPLICATE,     100 - 50:
                             receiptb2# c2-1,2076$,50:NEXT(2075$);

2075$         ASSIGN:        Separate 16.NumberOut Orig=Separate 16.NumberOut Orig + 1:NEXT(251$);

2076$         ASSIGN:        Separate 16.NumberOut Dup=Separate 16.NumberOut Dup + 1:NEXT(251$);


;
;
;     Model statements for module:  Process 21
;
251$          ASSIGN:        Process 21.NumberIn=Process 21.NumberIn + 1:
                             Process 21.WIP=Process 21.WIP+1;
2106$         STACK,         1:Save:NEXT(2080$);

2080$         QUEUE,         Process 21.Queue;
2079$         SEIZE,         2,VA:
                             Resource 15,1:NEXT(2078$);

2078$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c2,10)),,VA:NEXT(2121$);

2121$         ASSIGN:        Process 21.WaitTime=Process 21.WaitTime + Diff.WaitTime;
2085$         TALLY:         Process 21.WaitTimePerEntity,Diff.WaitTime,1;
2087$         TALLY:         Process 21.TotalTimePerEntity,Diff.StartTime,1;
2111$         ASSIGN:        Process 21.VATime=Process 21.VATime + Diff.VATime;
2112$         TALLY:         Process 21.VATimePerEntity,Diff.VATime,1;
2077$         RELEASE:       Resource 15,1;
2126$         STACK,         1:Destroy:NEXT(2125$);

2125$         ASSIGN:        Process 21.NumberOut=Process 21.NumberOut + 1:
                             Process 21.WIP=Process 21.WIP-1:NEXT(233$);


;
;
;     Model statements for module:  Create 25
;

2128$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c2:MinutesToBaseTime(1440):NEXT(2129$);

2129$         ASSIGN:        Create for receiving c shift1 c2.NumberOut=Create for receiving c shift1 c2.NumberOut + 1
                             :NEXT(253$);


;
;
;     Model statements for module:  Decide 130
;
253$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2132$,Yes:
                             Else,2133$,Yes;
2132$         ASSIGN:        Decide 130.NumberOut True=Decide 130.NumberOut True + 1:NEXT(254$);

2133$         ASSIGN:        Decide 130.NumberOut False=Decide 130.NumberOut False + 1:NEXT(255$);


;
;
;     Model statements for module:  Assign 89
;
254$          ASSIGN:        receiptc1# c2=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,75)
                             :NEXT(256$);


;
;
;     Model statements for module:  Decide 131
;
256$          BRANCH,        1:
                             If,receiptc1# c2==0,237$,Yes:
                             If,receiptc1# c2==1,257$,Yes:
                             Else,258$,Yes;

;
;
;     Model statements for module:  Separate 17
;
258$          DUPLICATE,     100 - 50:
                             receiptc1# c2-1,2138$,50:NEXT(2137$);

2137$         ASSIGN:        Separate 17.NumberOut Orig=Separate 17.NumberOut Orig + 1:NEXT(257$);

2138$         ASSIGN:        Separate 17.NumberOut Dup=Separate 17.NumberOut Dup + 1:NEXT(257$);


;
;
;     Model statements for module:  Process 22
;
257$          ASSIGN:        Process 22.NumberIn=Process 22.NumberIn + 1:
                             Process 22.WIP=Process 22.WIP+1;
2168$         STACK,         1:Save:NEXT(2142$);

2142$         QUEUE,         Process 22.Queue;
2141$         SEIZE,         2,VA:
                             Resource 16,1:NEXT(2140$);

2140$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c2,11)),,VA:NEXT(2183$);

2183$         ASSIGN:        Process 22.WaitTime=Process 22.WaitTime + Diff.WaitTime;
2147$         TALLY:         Process 22.WaitTimePerEntity,Diff.WaitTime,1;
2149$         TALLY:         Process 22.TotalTimePerEntity,Diff.StartTime,1;
2173$         ASSIGN:        Process 22.VATime=Process 22.VATime + Diff.VATime;
2174$         TALLY:         Process 22.VATimePerEntity,Diff.VATime,1;
2139$         RELEASE:       Resource 16,1;
2188$         STACK,         1:Destroy:NEXT(2187$);

2187$         ASSIGN:        Process 22.NumberOut=Process 22.NumberOut + 1:
                             Process 22.WIP=Process 22.WIP-1:NEXT(234$);


;
;
;     Model statements for module:  Assign 84
;
234$          ASSIGN:        producttype=3:NEXT(180$);


;
;
;     Model statements for module:  Assign 90
;
255$          ASSIGN:        receiptc2# c2=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,76)
                             :NEXT(259$);


;
;
;     Model statements for module:  Decide 132
;
259$          BRANCH,        1:
                             If,receiptc2# c2==0,237$,Yes:
                             If,receiptc2# c2==1,260$,Yes:
                             Else,261$,Yes;

;
;
;     Model statements for module:  Separate 18
;
261$          DUPLICATE,     100 - 50:
                             receiptc2# c2-1,2194$,50:NEXT(2193$);

2193$         ASSIGN:        Separate 18.NumberOut Orig=Separate 18.NumberOut Orig + 1:NEXT(260$);

2194$         ASSIGN:        Separate 18.NumberOut Dup=Separate 18.NumberOut Dup + 1:NEXT(260$);


;
;
;     Model statements for module:  Process 23
;
260$          ASSIGN:        Process 23.NumberIn=Process 23.NumberIn + 1:
                             Process 23.WIP=Process 23.WIP+1;
2224$         STACK,         1:Save:NEXT(2198$);

2198$         QUEUE,         Process 23.Queue;
2197$         SEIZE,         2,VA:
                             Resource 17,1:NEXT(2196$);

2196$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c2,12)),,VA:NEXT(2239$);

2239$         ASSIGN:        Process 23.WaitTime=Process 23.WaitTime + Diff.WaitTime;
2203$         TALLY:         Process 23.WaitTimePerEntity,Diff.WaitTime,1;
2205$         TALLY:         Process 23.TotalTimePerEntity,Diff.StartTime,1;
2229$         ASSIGN:        Process 23.VATime=Process 23.VATime + Diff.VATime;
2230$         TALLY:         Process 23.VATimePerEntity,Diff.VATime,1;
2195$         RELEASE:       Resource 17,1;
2244$         STACK,         1:Destroy:NEXT(2243$);

2243$         ASSIGN:        Process 23.NumberOut=Process 23.NumberOut + 1:
                             Process 23.WIP=Process 23.WIP-1:NEXT(234$);


;
;
;     Model statements for module:  Create 27
;

2246$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c2:MinutesToBaseTime(1440):NEXT(2247$);

2247$         ASSIGN:        Create for receiving a shift2 c2.NumberOut=Create for receiving a shift2 c2.NumberOut + 1
                             :NEXT(240$);


;
;
;     Model statements for module:  Decide 125
;
240$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2250$,Yes:
                             Else,2251$,Yes;
2250$         ASSIGN:        Decide 125.NumberOut True=Decide 125.NumberOut True + 1:NEXT(235$);

2251$         ASSIGN:        Decide 125.NumberOut False=Decide 125.NumberOut False + 1:NEXT(241$);


;
;
;     Model statements for module:  Assign 85
;
235$          ASSIGN:        receipta1# c2=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,71)
                             :NEXT(236$);


;
;
;     Model statements for module:  Decide 124
;
236$          BRANCH,        1:
                             If,receipta1# c2==0,237$,Yes:
                             If,receipta1# c2==1,238$,Yes:
                             Else,239$,Yes;

;
;
;     Model statements for module:  Separate 13
;
239$          DUPLICATE,     100 - 50:
                             receipta1# c2-1,2256$,50:NEXT(2255$);

2255$         ASSIGN:        Separate 13.NumberOut Orig=Separate 13.NumberOut Orig + 1:NEXT(238$);

2256$         ASSIGN:        Separate 13.NumberOut Dup=Separate 13.NumberOut Dup + 1:NEXT(238$);


;
;
;     Model statements for module:  Process 18
;
238$          ASSIGN:        Process 18.NumberIn=Process 18.NumberIn + 1:
                             Process 18.WIP=Process 18.WIP+1;
2286$         STACK,         1:Save:NEXT(2260$);

2260$         QUEUE,         Process 18.Queue;
2259$         SEIZE,         2,VA:
                             Resource 12,1:NEXT(2258$);

2258$         DELAY:         HoursToBaseTime(expo(10/receipta1# c2,7)),,VA:NEXT(2301$);

2301$         ASSIGN:        Process 18.WaitTime=Process 18.WaitTime + Diff.WaitTime;
2265$         TALLY:         Process 18.WaitTimePerEntity,Diff.WaitTime,1;
2267$         TALLY:         Process 18.TotalTimePerEntity,Diff.StartTime,1;
2291$         ASSIGN:        Process 18.VATime=Process 18.VATime + Diff.VATime;
2292$         TALLY:         Process 18.VATimePerEntity,Diff.VATime,1;
2257$         RELEASE:       Resource 12,1;
2306$         STACK,         1:Destroy:NEXT(2305$);

2305$         ASSIGN:        Process 18.NumberOut=Process 18.NumberOut + 1:
                             Process 18.WIP=Process 18.WIP-1:NEXT(232$);


;
;
;     Model statements for module:  Assign 82
;
232$          ASSIGN:        producttype=1:NEXT(180$);


;
;
;     Model statements for module:  Assign 86
;
241$          ASSIGN:        receipta2# c2=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,72)
                             :NEXT(242$);


;
;
;     Model statements for module:  Decide 126
;
242$          BRANCH,        1:
                             If,receipta2# c2==0,237$,Yes:
                             If,receipta2# c2==1,244$,Yes:
                             Else,243$,Yes;

;
;
;     Model statements for module:  Separate 14
;
243$          DUPLICATE,     100 - 50:
                             receipta2# c2-1,2312$,50:NEXT(2311$);

2311$         ASSIGN:        Separate 14.NumberOut Orig=Separate 14.NumberOut Orig + 1:NEXT(244$);

2312$         ASSIGN:        Separate 14.NumberOut Dup=Separate 14.NumberOut Dup + 1:NEXT(244$);


;
;
;     Model statements for module:  Process 19
;
244$          ASSIGN:        Process 19.NumberIn=Process 19.NumberIn + 1:
                             Process 19.WIP=Process 19.WIP+1;
2342$         STACK,         1:Save:NEXT(2316$);

2316$         QUEUE,         Process 19.Queue;
2315$         SEIZE,         2,VA:
                             Resource 13,1:NEXT(2314$);

2314$         DELAY:         HoursToBaseTime(expo(14/receipta2# c2,8)),,VA:NEXT(2357$);

2357$         ASSIGN:        Process 19.WaitTime=Process 19.WaitTime + Diff.WaitTime;
2321$         TALLY:         Process 19.WaitTimePerEntity,Diff.WaitTime,1;
2323$         TALLY:         Process 19.TotalTimePerEntity,Diff.StartTime,1;
2347$         ASSIGN:        Process 19.VATime=Process 19.VATime + Diff.VATime;
2348$         TALLY:         Process 19.VATimePerEntity,Diff.VATime,1;
2313$         RELEASE:       Resource 13,1;
2362$         STACK,         1:Destroy:NEXT(2361$);

2361$         ASSIGN:        Process 19.NumberOut=Process 19.NumberOut + 1:
                             Process 19.WIP=Process 19.WIP-1:NEXT(232$);


;
;
;     Model statements for module:  Create 28
;

2364$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c2:MinutesToBaseTime(1440):NEXT(2365$);

2365$         ASSIGN:        Create for receiving b shift2 c2.NumberOut=Create for receiving b shift2 c2.NumberOut + 1
                             :NEXT(245$);


;
;
;     Model statements for module:  Create 29
;

2368$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c2:MinutesToBaseTime(1440):NEXT(2369$);

2369$         ASSIGN:        Create for receiving c shift2 c2.NumberOut=Create for receiving c shift2 c2.NumberOut + 1
                             :NEXT(253$);


;
;
;     Model statements for module:  Create 39
;

2372$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c2:MinutesToBaseTime(1440):NEXT(2373$);

2373$         ASSIGN:        Create for shipment b shift1 c2.NumberOut=Create for shipment b shift1 c2.NumberOut + 1:NEXT(275$);


;
;
;     Model statements for module:  Decide 145
;
275$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2376$,Yes:
                             Else,2377$,Yes;
2376$         ASSIGN:        Decide 145.NumberOut True=Decide 145.NumberOut True + 1:NEXT(276$);

2377$         ASSIGN:        Decide 145.NumberOut False=Decide 145.NumberOut False + 1:NEXT(277$);


;
;
;     Model statements for module:  Assign 105
;
276$          ASSIGN:        departureb1# c2=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,103):NEXT(278$);


;
;
;     Model statements for module:  Decide 146
;
278$          BRANCH,        1:
                             If,departureb1# c2==0,269$,Yes:
                             If,departureb1# c2==1,279$,Yes:
                             Else,280$,Yes;

;
;
;     Model statements for module:  Separate 27
;
280$          DUPLICATE,     100 - 50:
                             departureb1# c2-1,2382$,50:NEXT(2381$);

2381$         ASSIGN:        Separate 27.NumberOut Orig=Separate 27.NumberOut Orig + 1:NEXT(279$);

2382$         ASSIGN:        Separate 27.NumberOut Dup=Separate 27.NumberOut Dup + 1:NEXT(279$);


;
;
;     Model statements for module:  Process 32
;
279$          ASSIGN:        Process 32.NumberIn=Process 32.NumberIn + 1:
                             Process 32.WIP=Process 32.WIP+1;
2412$         STACK,         1:Save:NEXT(2386$);

2386$         QUEUE,         Process 32.Queue;
2385$         SEIZE,         2,VA:
                             Resource 20,1:NEXT(2384$);

2384$         DELAY:         HoursToBaseTime(expo(10/departureb1# c2,39)),,VA:NEXT(2427$);

2427$         ASSIGN:        Process 32.WaitTime=Process 32.WaitTime + Diff.WaitTime;
2391$         TALLY:         Process 32.WaitTimePerEntity,Diff.WaitTime,1;
2393$         TALLY:         Process 32.TotalTimePerEntity,Diff.StartTime,1;
2417$         ASSIGN:        Process 32.VATime=Process 32.VATime + Diff.VATime;
2418$         TALLY:         Process 32.VATimePerEntity,Diff.VATime,1;
2383$         RELEASE:       Resource 20,1;
2432$         STACK,         1:Destroy:NEXT(2431$);

2431$         ASSIGN:        Process 32.NumberOut=Process 32.NumberOut + 1:
                             Process 32.WIP=Process 32.WIP-1:NEXT(263$);


;
;
;     Model statements for module:  Assign 101
;
263$          ASSIGN:        type=2:NEXT(158$);


;
;
;     Model statements for module:  Dispose 24
;
269$          ASSIGN:        Dispose 24.NumberOut=Dispose 24.NumberOut + 1;
2434$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 106
;
277$          ASSIGN:        departureb2# c2=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,104)
                             :NEXT(281$);


;
;
;     Model statements for module:  Decide 147
;
281$          BRANCH,        1:
                             If,departureb2# c2==0,269$,Yes:
                             If,departureb2# c2==1,282$,Yes:
                             Else,283$,Yes;

;
;
;     Model statements for module:  Separate 28
;
283$          DUPLICATE,     100 - 50:
                             departureb2# c2-1,2439$,50:NEXT(2438$);

2438$         ASSIGN:        Separate 28.NumberOut Orig=Separate 28.NumberOut Orig + 1:NEXT(282$);

2439$         ASSIGN:        Separate 28.NumberOut Dup=Separate 28.NumberOut Dup + 1:NEXT(282$);


;
;
;     Model statements for module:  Process 33
;
282$          ASSIGN:        Process 33.NumberIn=Process 33.NumberIn + 1:
                             Process 33.WIP=Process 33.WIP+1;
2469$         STACK,         1:Save:NEXT(2443$);

2443$         QUEUE,         Process 33.Queue;
2442$         SEIZE,         2,VA:
                             Resource 21,1:NEXT(2441$);

2441$         DELAY:         HoursToBaseTime(expo(14/departureb2# c2,40)),,VA:NEXT(2484$);

2484$         ASSIGN:        Process 33.WaitTime=Process 33.WaitTime + Diff.WaitTime;
2448$         TALLY:         Process 33.WaitTimePerEntity,Diff.WaitTime,1;
2450$         TALLY:         Process 33.TotalTimePerEntity,Diff.StartTime,1;
2474$         ASSIGN:        Process 33.VATime=Process 33.VATime + Diff.VATime;
2475$         TALLY:         Process 33.VATimePerEntity,Diff.VATime,1;
2440$         RELEASE:       Resource 21,1;
2489$         STACK,         1:Destroy:NEXT(2488$);

2488$         ASSIGN:        Process 33.NumberOut=Process 33.NumberOut + 1:
                             Process 33.WIP=Process 33.WIP-1:NEXT(263$);


;
;
;     Model statements for module:  Create 40
;

2491$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c2:MinutesToBaseTime(1440):NEXT(2492$);

2492$         ASSIGN:        Create for shipment c shift1 c2.NumberOut=Create for shipment c shift1 c2.NumberOut + 1:NEXT(284$);


;
;
;     Model statements for module:  Decide 148
;
284$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2495$,Yes:
                             Else,2496$,Yes;
2495$         ASSIGN:        Decide 148.NumberOut True=Decide 148.NumberOut True + 1:NEXT(285$);

2496$         ASSIGN:        Decide 148.NumberOut False=Decide 148.NumberOut False + 1:NEXT(286$);


;
;
;     Model statements for module:  Assign 107
;
285$          ASSIGN:        departurec1# c2=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,105):NEXT(287$);


;
;
;     Model statements for module:  Decide 149
;
287$          BRANCH,        1:
                             If,departurec1# c2==0,269$,Yes:
                             If,departurec1# c2==1,288$,Yes:
                             Else,289$,Yes;

;
;
;     Model statements for module:  Separate 29
;
289$          DUPLICATE,     100 - 50:
                             departurec1# c2-1,2501$,50:NEXT(2500$);

2500$         ASSIGN:        Separate 29.NumberOut Orig=Separate 29.NumberOut Orig + 1:NEXT(288$);

2501$         ASSIGN:        Separate 29.NumberOut Dup=Separate 29.NumberOut Dup + 1:NEXT(288$);


;
;
;     Model statements for module:  Process 34
;
288$          ASSIGN:        Process 34.NumberIn=Process 34.NumberIn + 1:
                             Process 34.WIP=Process 34.WIP+1;
2531$         STACK,         1:Save:NEXT(2505$);

2505$         QUEUE,         Process 34.Queue;
2504$         SEIZE,         2,VA:
                             Resource 22,1:NEXT(2503$);

2503$         DELAY:         HoursToBaseTime(expo(10/departurec1# c2,41)),,VA:NEXT(2546$);

2546$         ASSIGN:        Process 34.WaitTime=Process 34.WaitTime + Diff.WaitTime;
2510$         TALLY:         Process 34.WaitTimePerEntity,Diff.WaitTime,1;
2512$         TALLY:         Process 34.TotalTimePerEntity,Diff.StartTime,1;
2536$         ASSIGN:        Process 34.VATime=Process 34.VATime + Diff.VATime;
2537$         TALLY:         Process 34.VATimePerEntity,Diff.VATime,1;
2502$         RELEASE:       Resource 22,1;
2551$         STACK,         1:Destroy:NEXT(2550$);

2550$         ASSIGN:        Process 34.NumberOut=Process 34.NumberOut + 1:
                             Process 34.WIP=Process 34.WIP-1:NEXT(264$);


;
;
;     Model statements for module:  Assign 102
;
264$          ASSIGN:        type=3:NEXT(158$);


;
;
;     Model statements for module:  Assign 108
;
286$          ASSIGN:        departurec2# c2=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,106):NEXT(290$);


;
;
;     Model statements for module:  Decide 150
;
290$          BRANCH,        1:
                             If,departurec2# c2==0,269$,Yes:
                             If,departurec2# c2==1,291$,Yes:
                             Else,292$,Yes;

;
;
;     Model statements for module:  Separate 30
;
292$          DUPLICATE,     100 - 50:
                             departurec2# c2-1,2557$,50:NEXT(2556$);

2556$         ASSIGN:        Separate 30.NumberOut Orig=Separate 30.NumberOut Orig + 1:NEXT(291$);

2557$         ASSIGN:        Separate 30.NumberOut Dup=Separate 30.NumberOut Dup + 1:NEXT(291$);


;
;
;     Model statements for module:  Process 35
;
291$          ASSIGN:        Process 35.NumberIn=Process 35.NumberIn + 1:
                             Process 35.WIP=Process 35.WIP+1;
2587$         STACK,         1:Save:NEXT(2561$);

2561$         QUEUE,         Process 35.Queue;
2560$         SEIZE,         2,VA:
                             Resource 23,1:NEXT(2559$);

2559$         DELAY:         HoursToBaseTime(expo(14/departurec2# c2,42)),,VA:NEXT(2602$);

2602$         ASSIGN:        Process 35.WaitTime=Process 35.WaitTime + Diff.WaitTime;
2566$         TALLY:         Process 35.WaitTimePerEntity,Diff.WaitTime,1;
2568$         TALLY:         Process 35.TotalTimePerEntity,Diff.StartTime,1;
2592$         ASSIGN:        Process 35.VATime=Process 35.VATime + Diff.VATime;
2593$         TALLY:         Process 35.VATimePerEntity,Diff.VATime,1;
2558$         RELEASE:       Resource 23,1;
2607$         STACK,         1:Destroy:NEXT(2606$);

2606$         ASSIGN:        Process 35.NumberOut=Process 35.NumberOut + 1:
                             Process 35.WIP=Process 35.WIP-1:NEXT(264$);


;
;
;     Model statements for module:  Create 42
;

2609$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c2:MinutesToBaseTime(1440):NEXT(2610$);

2610$         ASSIGN:        Create for shipmenta shift2 c2.NumberOut=Create for shipmenta shift2 c2.NumberOut + 1:NEXT(266$);


;
;
;     Model statements for module:  Decide 142
;
266$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2613$,Yes:
                             Else,2614$,Yes;
2613$         ASSIGN:        Decide 142.NumberOut True=Decide 142.NumberOut True + 1:NEXT(265$);

2614$         ASSIGN:        Decide 142.NumberOut False=Decide 142.NumberOut False + 1:NEXT(267$);


;
;
;     Model statements for module:  Assign 103
;
265$          ASSIGN:        departurea1# c2=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,101):NEXT(268$);


;
;
;     Model statements for module:  Decide 143
;
268$          BRANCH,        1:
                             If,departurea1# c2==0,269$,Yes:
                             If,departurea1# c2==1,270$,Yes:
                             Else,271$,Yes;

;
;
;     Model statements for module:  Separate 25
;
271$          DUPLICATE,     100 - 50:
                             departurea1# c2-1,2619$,50:NEXT(2618$);

2618$         ASSIGN:        Separate 25.NumberOut Orig=Separate 25.NumberOut Orig + 1:NEXT(270$);

2619$         ASSIGN:        Separate 25.NumberOut Dup=Separate 25.NumberOut Dup + 1:NEXT(270$);


;
;
;     Model statements for module:  Process 30
;
270$          ASSIGN:        Process 30.NumberIn=Process 30.NumberIn + 1:
                             Process 30.WIP=Process 30.WIP+1;
2649$         STACK,         1:Save:NEXT(2623$);

2623$         QUEUE,         Process 30.Queue;
2622$         SEIZE,         2,VA:
                             Resource 18,1:NEXT(2621$);

2621$         DELAY:         HoursToBaseTime(expo(10/departurea1# c2,37)),,VA:NEXT(2664$);

2664$         ASSIGN:        Process 30.WaitTime=Process 30.WaitTime + Diff.WaitTime;
2628$         TALLY:         Process 30.WaitTimePerEntity,Diff.WaitTime,1;
2630$         TALLY:         Process 30.TotalTimePerEntity,Diff.StartTime,1;
2654$         ASSIGN:        Process 30.VATime=Process 30.VATime + Diff.VATime;
2655$         TALLY:         Process 30.VATimePerEntity,Diff.VATime,1;
2620$         RELEASE:       Resource 18,1;
2669$         STACK,         1:Destroy:NEXT(2668$);

2668$         ASSIGN:        Process 30.NumberOut=Process 30.NumberOut + 1:
                             Process 30.WIP=Process 30.WIP-1:NEXT(262$);


;
;
;     Model statements for module:  Assign 100
;
262$          ASSIGN:        type=1:NEXT(158$);


;
;
;     Model statements for module:  Assign 104
;
267$          ASSIGN:        departurea2# c2=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,102):NEXT(272$);


;
;
;     Model statements for module:  Decide 144
;
272$          BRANCH,        1:
                             If,departurea2# c2==0,269$,Yes:
                             If,departurea2# c2==1,274$,Yes:
                             Else,273$,Yes;

;
;
;     Model statements for module:  Separate 26
;
273$          DUPLICATE,     100 - 50:
                             departurea2# c2-1,2675$,50:NEXT(2674$);

2674$         ASSIGN:        Separate 26.NumberOut Orig=Separate 26.NumberOut Orig + 1:NEXT(274$);

2675$         ASSIGN:        Separate 26.NumberOut Dup=Separate 26.NumberOut Dup + 1:NEXT(274$);


;
;
;     Model statements for module:  Process 31
;
274$          ASSIGN:        Process 31.NumberIn=Process 31.NumberIn + 1:
                             Process 31.WIP=Process 31.WIP+1;
2705$         STACK,         1:Save:NEXT(2679$);

2679$         QUEUE,         Process 31.Queue;
2678$         SEIZE,         2,VA:
                             Resource 19,1:NEXT(2677$);

2677$         DELAY:         HoursToBaseTime(expo(14/departurea2# c2,38)),,VA:NEXT(2720$);

2720$         ASSIGN:        Process 31.WaitTime=Process 31.WaitTime + Diff.WaitTime;
2684$         TALLY:         Process 31.WaitTimePerEntity,Diff.WaitTime,1;
2686$         TALLY:         Process 31.TotalTimePerEntity,Diff.StartTime,1;
2710$         ASSIGN:        Process 31.VATime=Process 31.VATime + Diff.VATime;
2711$         TALLY:         Process 31.VATimePerEntity,Diff.VATime,1;
2676$         RELEASE:       Resource 19,1;
2725$         STACK,         1:Destroy:NEXT(2724$);

2724$         ASSIGN:        Process 31.NumberOut=Process 31.NumberOut + 1:
                             Process 31.WIP=Process 31.WIP-1:NEXT(262$);


;
;
;     Model statements for module:  Create 43
;

2727$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c2:MinutesToBaseTime(1440):NEXT(2728$);

2728$         ASSIGN:        Create for shipment b shift2 c2.NumberOut=Create for shipment b shift2 c2.NumberOut + 1:NEXT(275$);


;
;
;     Model statements for module:  Create 45
;

2731$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c3:MinutesToBaseTime(1440):NEXT(2732$);

2732$         ASSIGN:        Create for receiving b shift1 c3.NumberOut=Create for receiving b shift1 c3.NumberOut + 1
                             :NEXT(316$);


;
;
;     Model statements for module:  Decide 157
;
316$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2735$,Yes:
                             Else,2736$,Yes;
2735$         ASSIGN:        Decide 157.NumberOut True=Decide 157.NumberOut True + 1:NEXT(317$);

2736$         ASSIGN:        Decide 157.NumberOut False=Decide 157.NumberOut False + 1:NEXT(318$);


;
;
;     Model statements for module:  Assign 117
;
317$          ASSIGN:        receiptb1# c3=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,79)
                             :NEXT(319$);


;
;
;     Model statements for module:  Decide 158
;
319$          BRANCH,        1:
                             If,receiptb1# c3==0,308$,Yes:
                             If,receiptb1# c3==1,320$,Yes:
                             Else,321$,Yes;

;
;
;     Model statements for module:  Separate 33
;
321$          DUPLICATE,     100 - 50:
                             receiptb1# c3-1,2741$,50:NEXT(2740$);

2740$         ASSIGN:        Separate 33.NumberOut Orig=Separate 33.NumberOut Orig + 1:NEXT(320$);

2741$         ASSIGN:        Separate 33.NumberOut Dup=Separate 33.NumberOut Dup + 1:NEXT(320$);


;
;
;     Model statements for module:  Process 38
;
320$          ASSIGN:        Process 38.NumberIn=Process 38.NumberIn + 1:
                             Process 38.WIP=Process 38.WIP+1;
2771$         STACK,         1:Save:NEXT(2745$);

2745$         QUEUE,         Process 38.Queue;
2744$         SEIZE,         2,VA:
                             Resource 26,1:NEXT(2743$);

2743$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c3,15)),,VA:NEXT(2786$);

2786$         ASSIGN:        Process 38.WaitTime=Process 38.WaitTime + Diff.WaitTime;
2750$         TALLY:         Process 38.WaitTimePerEntity,Diff.WaitTime,1;
2752$         TALLY:         Process 38.TotalTimePerEntity,Diff.StartTime,1;
2776$         ASSIGN:        Process 38.VATime=Process 38.VATime + Diff.VATime;
2777$         TALLY:         Process 38.VATimePerEntity,Diff.VATime,1;
2742$         RELEASE:       Resource 26,1;
2791$         STACK,         1:Destroy:NEXT(2790$);

2790$         ASSIGN:        Process 38.NumberOut=Process 38.NumberOut + 1:
                             Process 38.WIP=Process 38.WIP-1:NEXT(304$);


;
;
;     Model statements for module:  Assign 113
;
304$          ASSIGN:        producttype=2:NEXT(180$);


;
;
;     Model statements for module:  Dispose 25
;
308$          ASSIGN:        Dispose 25.NumberOut=Dispose 25.NumberOut + 1;
2793$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 118
;
318$          ASSIGN:        receiptb2# c3=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,80)
                             :NEXT(322$);


;
;
;     Model statements for module:  Decide 159
;
322$          BRANCH,        1:
                             If,receiptb2# c3==0,308$,Yes:
                             If,receiptb2# c3==1,323$,Yes:
                             Else,324$,Yes;

;
;
;     Model statements for module:  Separate 34
;
324$          DUPLICATE,     100 - 50:
                             receiptb2# c3-1,2798$,50:NEXT(2797$);

2797$         ASSIGN:        Separate 34.NumberOut Orig=Separate 34.NumberOut Orig + 1:NEXT(323$);

2798$         ASSIGN:        Separate 34.NumberOut Dup=Separate 34.NumberOut Dup + 1:NEXT(323$);


;
;
;     Model statements for module:  Process 39
;
323$          ASSIGN:        Process 39.NumberIn=Process 39.NumberIn + 1:
                             Process 39.WIP=Process 39.WIP+1;
2828$         STACK,         1:Save:NEXT(2802$);

2802$         QUEUE,         Process 39.Queue;
2801$         SEIZE,         2,VA:
                             Resource 27,1:NEXT(2800$);

2800$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c3,16)),,VA:NEXT(2843$);

2843$         ASSIGN:        Process 39.WaitTime=Process 39.WaitTime + Diff.WaitTime;
2807$         TALLY:         Process 39.WaitTimePerEntity,Diff.WaitTime,1;
2809$         TALLY:         Process 39.TotalTimePerEntity,Diff.StartTime,1;
2833$         ASSIGN:        Process 39.VATime=Process 39.VATime + Diff.VATime;
2834$         TALLY:         Process 39.VATimePerEntity,Diff.VATime,1;
2799$         RELEASE:       Resource 27,1;
2848$         STACK,         1:Destroy:NEXT(2847$);

2847$         ASSIGN:        Process 39.NumberOut=Process 39.NumberOut + 1:
                             Process 39.WIP=Process 39.WIP-1:NEXT(304$);


;
;
;     Model statements for module:  Create 46
;

2850$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c3:MinutesToBaseTime(1440):NEXT(2851$);

2851$         ASSIGN:        Create for receiving c shift1 c3.NumberOut=Create for receiving c shift1 c3.NumberOut + 1
                             :NEXT(325$);


;
;
;     Model statements for module:  Decide 160
;
325$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2854$,Yes:
                             Else,2855$,Yes;
2854$         ASSIGN:        Decide 160.NumberOut True=Decide 160.NumberOut True + 1:NEXT(326$);

2855$         ASSIGN:        Decide 160.NumberOut False=Decide 160.NumberOut False + 1:NEXT(327$);


;
;
;     Model statements for module:  Assign 119
;
326$          ASSIGN:        receiptc1# c3=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,81)
                             :NEXT(328$);


;
;
;     Model statements for module:  Decide 161
;
328$          BRANCH,        1:
                             If,receiptc1# c3==0,308$,Yes:
                             If,receiptc1# c3==1,329$,Yes:
                             Else,330$,Yes;

;
;
;     Model statements for module:  Separate 35
;
330$          DUPLICATE,     100 - 50:
                             receiptc1# c3-1,2860$,50:NEXT(2859$);

2859$         ASSIGN:        Separate 35.NumberOut Orig=Separate 35.NumberOut Orig + 1:NEXT(329$);

2860$         ASSIGN:        Separate 35.NumberOut Dup=Separate 35.NumberOut Dup + 1:NEXT(329$);


;
;
;     Model statements for module:  Process 40
;
329$          ASSIGN:        Process 40.NumberIn=Process 40.NumberIn + 1:
                             Process 40.WIP=Process 40.WIP+1;
2890$         STACK,         1:Save:NEXT(2864$);

2864$         QUEUE,         Process 40.Queue;
2863$         SEIZE,         2,VA:
                             Resource 28,1:NEXT(2862$);

2862$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c3,17)),,VA:NEXT(2905$);

2905$         ASSIGN:        Process 40.WaitTime=Process 40.WaitTime + Diff.WaitTime;
2869$         TALLY:         Process 40.WaitTimePerEntity,Diff.WaitTime,1;
2871$         TALLY:         Process 40.TotalTimePerEntity,Diff.StartTime,1;
2895$         ASSIGN:        Process 40.VATime=Process 40.VATime + Diff.VATime;
2896$         TALLY:         Process 40.VATimePerEntity,Diff.VATime,1;
2861$         RELEASE:       Resource 28,1;
2910$         STACK,         1:Destroy:NEXT(2909$);

2909$         ASSIGN:        Process 40.NumberOut=Process 40.NumberOut + 1:
                             Process 40.WIP=Process 40.WIP-1:NEXT(305$);


;
;
;     Model statements for module:  Assign 114
;
305$          ASSIGN:        producttype=3:NEXT(180$);


;
;
;     Model statements for module:  Assign 120
;
327$          ASSIGN:        receiptc2# c3=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,82)
                             :NEXT(331$);


;
;
;     Model statements for module:  Decide 162
;
331$          BRANCH,        1:
                             If,receiptc2# c3==0,308$,Yes:
                             If,receiptc2# c3==1,332$,Yes:
                             Else,333$,Yes;

;
;
;     Model statements for module:  Separate 36
;
333$          DUPLICATE,     100 - 50:
                             receiptc2# c3-1,2916$,50:NEXT(2915$);

2915$         ASSIGN:        Separate 36.NumberOut Orig=Separate 36.NumberOut Orig + 1:NEXT(332$);

2916$         ASSIGN:        Separate 36.NumberOut Dup=Separate 36.NumberOut Dup + 1:NEXT(332$);


;
;
;     Model statements for module:  Process 41
;
332$          ASSIGN:        Process 41.NumberIn=Process 41.NumberIn + 1:
                             Process 41.WIP=Process 41.WIP+1;
2946$         STACK,         1:Save:NEXT(2920$);

2920$         QUEUE,         Process 41.Queue;
2919$         SEIZE,         2,VA:
                             Resource 29,1:NEXT(2918$);

2918$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c3,18)),,VA:NEXT(2961$);

2961$         ASSIGN:        Process 41.WaitTime=Process 41.WaitTime + Diff.WaitTime;
2925$         TALLY:         Process 41.WaitTimePerEntity,Diff.WaitTime,1;
2927$         TALLY:         Process 41.TotalTimePerEntity,Diff.StartTime,1;
2951$         ASSIGN:        Process 41.VATime=Process 41.VATime + Diff.VATime;
2952$         TALLY:         Process 41.VATimePerEntity,Diff.VATime,1;
2917$         RELEASE:       Resource 29,1;
2966$         STACK,         1:Destroy:NEXT(2965$);

2965$         ASSIGN:        Process 41.NumberOut=Process 41.NumberOut + 1:
                             Process 41.WIP=Process 41.WIP-1:NEXT(305$);


;
;
;     Model statements for module:  Create 48
;

2968$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c3:MinutesToBaseTime(1440):NEXT(2969$);

2969$         ASSIGN:        Create for receiving a shift2 c3.NumberOut=Create for receiving a shift2 c3.NumberOut + 1
                             :NEXT(311$);


;
;
;     Model statements for module:  Decide 155
;
311$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2972$,Yes:
                             Else,2973$,Yes;
2972$         ASSIGN:        Decide 155.NumberOut True=Decide 155.NumberOut True + 1:NEXT(306$);

2973$         ASSIGN:        Decide 155.NumberOut False=Decide 155.NumberOut False + 1:NEXT(312$);


;
;
;     Model statements for module:  Assign 115
;
306$          ASSIGN:        receipta1# c3=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,77)
                             :NEXT(307$);


;
;
;     Model statements for module:  Decide 154
;
307$          BRANCH,        1:
                             If,receipta1# c3==0,308$,Yes:
                             If,receipta1# c3==1,309$,Yes:
                             Else,310$,Yes;

;
;
;     Model statements for module:  Separate 31
;
310$          DUPLICATE,     100 - 50:
                             receipta1# c3-1,2978$,50:NEXT(2977$);

2977$         ASSIGN:        Separate 31.NumberOut Orig=Separate 31.NumberOut Orig + 1:NEXT(309$);

2978$         ASSIGN:        Separate 31.NumberOut Dup=Separate 31.NumberOut Dup + 1:NEXT(309$);


;
;
;     Model statements for module:  Process 36
;
309$          ASSIGN:        Process 36.NumberIn=Process 36.NumberIn + 1:
                             Process 36.WIP=Process 36.WIP+1;
3008$         STACK,         1:Save:NEXT(2982$);

2982$         QUEUE,         Process 36.Queue;
2981$         SEIZE,         2,VA:
                             Resource 24,1:NEXT(2980$);

2980$         DELAY:         HoursToBaseTime(expo(10/receipta1# c3,13)),,VA:NEXT(3023$);

3023$         ASSIGN:        Process 36.WaitTime=Process 36.WaitTime + Diff.WaitTime;
2987$         TALLY:         Process 36.WaitTimePerEntity,Diff.WaitTime,1;
2989$         TALLY:         Process 36.TotalTimePerEntity,Diff.StartTime,1;
3013$         ASSIGN:        Process 36.VATime=Process 36.VATime + Diff.VATime;
3014$         TALLY:         Process 36.VATimePerEntity,Diff.VATime,1;
2979$         RELEASE:       Resource 24,1;
3028$         STACK,         1:Destroy:NEXT(3027$);

3027$         ASSIGN:        Process 36.NumberOut=Process 36.NumberOut + 1:
                             Process 36.WIP=Process 36.WIP-1:NEXT(303$);


;
;
;     Model statements for module:  Assign 112
;
303$          ASSIGN:        producttype=1:NEXT(180$);


;
;
;     Model statements for module:  Assign 116
;
312$          ASSIGN:        receipta2# c3=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,78)
                             :NEXT(313$);


;
;
;     Model statements for module:  Decide 156
;
313$          BRANCH,        1:
                             If,receipta2# c3==0,308$,Yes:
                             If,receipta2# c3==1,315$,Yes:
                             Else,314$,Yes;

;
;
;     Model statements for module:  Separate 32
;
314$          DUPLICATE,     100 - 50:
                             receipta2# c3-1,3034$,50:NEXT(3033$);

3033$         ASSIGN:        Separate 32.NumberOut Orig=Separate 32.NumberOut Orig + 1:NEXT(315$);

3034$         ASSIGN:        Separate 32.NumberOut Dup=Separate 32.NumberOut Dup + 1:NEXT(315$);


;
;
;     Model statements for module:  Process 37
;
315$          ASSIGN:        Process 37.NumberIn=Process 37.NumberIn + 1:
                             Process 37.WIP=Process 37.WIP+1;
3064$         STACK,         1:Save:NEXT(3038$);

3038$         QUEUE,         Process 37.Queue;
3037$         SEIZE,         2,VA:
                             Resource 25,1:NEXT(3036$);

3036$         DELAY:         HoursToBaseTime(expo(14/receipta2# c3,14)),,VA:NEXT(3079$);

3079$         ASSIGN:        Process 37.WaitTime=Process 37.WaitTime + Diff.WaitTime;
3043$         TALLY:         Process 37.WaitTimePerEntity,Diff.WaitTime,1;
3045$         TALLY:         Process 37.TotalTimePerEntity,Diff.StartTime,1;
3069$         ASSIGN:        Process 37.VATime=Process 37.VATime + Diff.VATime;
3070$         TALLY:         Process 37.VATimePerEntity,Diff.VATime,1;
3035$         RELEASE:       Resource 25,1;
3084$         STACK,         1:Destroy:NEXT(3083$);

3083$         ASSIGN:        Process 37.NumberOut=Process 37.NumberOut + 1:
                             Process 37.WIP=Process 37.WIP-1:NEXT(303$);


;
;
;     Model statements for module:  Create 49
;

3086$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c3:MinutesToBaseTime(1440):NEXT(3087$);

3087$         ASSIGN:        Create for receiving b shift2 c3.NumberOut=Create for receiving b shift2 c3.NumberOut + 1
                             :NEXT(316$);


;
;
;     Model statements for module:  Create 50
;

3090$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c3:MinutesToBaseTime(1440):NEXT(3091$);

3091$         ASSIGN:        Create for receiving c shift2 c3.NumberOut=Create for receiving c shift2 c3.NumberOut + 1
                             :NEXT(325$);


;
;
;     Model statements for module:  Create 54
;

3094$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c3:MinutesToBaseTime(1440):NEXT(3095$);

3095$         ASSIGN:        Create for shipment b shift1 c3.NumberOut=Create for shipment b shift1 c3.NumberOut + 1:NEXT(347$);


;
;
;     Model statements for module:  Decide 166
;
347$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3098$,Yes:
                             Else,3099$,Yes;
3098$         ASSIGN:        Decide 166.NumberOut True=Decide 166.NumberOut True + 1:NEXT(348$);

3099$         ASSIGN:        Decide 166.NumberOut False=Decide 166.NumberOut False + 1:NEXT(349$);


;
;
;     Model statements for module:  Assign 126
;
348$          ASSIGN:        departureb1# c3=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,109):NEXT(350$);


;
;
;     Model statements for module:  Decide 167
;
350$          BRANCH,        1:
                             If,departureb1# c3==0,341$,Yes:
                             If,departureb1# c3==1,351$,Yes:
                             Else,352$,Yes;

;
;
;     Model statements for module:  Separate 39
;
352$          DUPLICATE,     100 - 50:
                             departureb1# c3-1,3104$,50:NEXT(3103$);

3103$         ASSIGN:        Separate 39.NumberOut Orig=Separate 39.NumberOut Orig + 1:NEXT(351$);

3104$         ASSIGN:        Separate 39.NumberOut Dup=Separate 39.NumberOut Dup + 1:NEXT(351$);


;
;
;     Model statements for module:  Process 44
;
351$          ASSIGN:        Process 44.NumberIn=Process 44.NumberIn + 1:
                             Process 44.WIP=Process 44.WIP+1;
3134$         STACK,         1:Save:NEXT(3108$);

3108$         QUEUE,         Process 44.Queue;
3107$         SEIZE,         2,VA:
                             Resource 32,1:NEXT(3106$);

3106$         DELAY:         HoursToBaseTime(expo(10/departureb1# c3,45)),,VA:NEXT(3149$);

3149$         ASSIGN:        Process 44.WaitTime=Process 44.WaitTime + Diff.WaitTime;
3113$         TALLY:         Process 44.WaitTimePerEntity,Diff.WaitTime,1;
3115$         TALLY:         Process 44.TotalTimePerEntity,Diff.StartTime,1;
3139$         ASSIGN:        Process 44.VATime=Process 44.VATime + Diff.VATime;
3140$         TALLY:         Process 44.VATimePerEntity,Diff.VATime,1;
3105$         RELEASE:       Resource 32,1;
3154$         STACK,         1:Destroy:NEXT(3153$);

3153$         ASSIGN:        Process 44.NumberOut=Process 44.NumberOut + 1:
                             Process 44.WIP=Process 44.WIP-1:NEXT(335$);


;
;
;     Model statements for module:  Assign 122
;
335$          ASSIGN:        type=2:NEXT(158$);


;
;
;     Model statements for module:  Dispose 26
;
341$          ASSIGN:        Dispose 26.NumberOut=Dispose 26.NumberOut + 1;
3156$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 127
;
349$          ASSIGN:        departureb2# c3=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,110)
                             :NEXT(353$);


;
;
;     Model statements for module:  Decide 168
;
353$          BRANCH,        1:
                             If,departureb2# c3==0,341$,Yes:
                             If,departureb2# c3==1,354$,Yes:
                             Else,355$,Yes;

;
;
;     Model statements for module:  Separate 40
;
355$          DUPLICATE,     100 - 50:
                             departureb2# c3-1,3161$,50:NEXT(3160$);

3160$         ASSIGN:        Separate 40.NumberOut Orig=Separate 40.NumberOut Orig + 1:NEXT(354$);

3161$         ASSIGN:        Separate 40.NumberOut Dup=Separate 40.NumberOut Dup + 1:NEXT(354$);


;
;
;     Model statements for module:  Process 45
;
354$          ASSIGN:        Process 45.NumberIn=Process 45.NumberIn + 1:
                             Process 45.WIP=Process 45.WIP+1;
3191$         STACK,         1:Save:NEXT(3165$);

3165$         QUEUE,         Process 45.Queue;
3164$         SEIZE,         2,VA:
                             Resource 33,1:NEXT(3163$);

3163$         DELAY:         HoursToBaseTime(expo(14/departureb2# c3,46)),,VA:NEXT(3206$);

3206$         ASSIGN:        Process 45.WaitTime=Process 45.WaitTime + Diff.WaitTime;
3170$         TALLY:         Process 45.WaitTimePerEntity,Diff.WaitTime,1;
3172$         TALLY:         Process 45.TotalTimePerEntity,Diff.StartTime,1;
3196$         ASSIGN:        Process 45.VATime=Process 45.VATime + Diff.VATime;
3197$         TALLY:         Process 45.VATimePerEntity,Diff.VATime,1;
3162$         RELEASE:       Resource 33,1;
3211$         STACK,         1:Destroy:NEXT(3210$);

3210$         ASSIGN:        Process 45.NumberOut=Process 45.NumberOut + 1:
                             Process 45.WIP=Process 45.WIP-1:NEXT(335$);


;
;
;     Model statements for module:  Create 55
;

3213$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c3:MinutesToBaseTime(1440):NEXT(3214$);

3214$         ASSIGN:        Create for shipment c shift1 c3.NumberOut=Create for shipment c shift1 c3.NumberOut + 1:NEXT(356$);


;
;
;     Model statements for module:  Decide 169
;
356$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3217$,Yes:
                             Else,3218$,Yes;
3217$         ASSIGN:        Decide 169.NumberOut True=Decide 169.NumberOut True + 1:NEXT(357$);

3218$         ASSIGN:        Decide 169.NumberOut False=Decide 169.NumberOut False + 1:NEXT(358$);


;
;
;     Model statements for module:  Assign 128
;
357$          ASSIGN:        departurec1# c3=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,111):NEXT(359$);


;
;
;     Model statements for module:  Decide 170
;
359$          BRANCH,        1:
                             If,departurec1# c3==0,341$,Yes:
                             If,departurec1# c3==1,360$,Yes:
                             Else,361$,Yes;

;
;
;     Model statements for module:  Separate 41
;
361$          DUPLICATE,     100 - 50:
                             departurec1# c3-1,3223$,50:NEXT(3222$);

3222$         ASSIGN:        Separate 41.NumberOut Orig=Separate 41.NumberOut Orig + 1:NEXT(360$);

3223$         ASSIGN:        Separate 41.NumberOut Dup=Separate 41.NumberOut Dup + 1:NEXT(360$);


;
;
;     Model statements for module:  Process 46
;
360$          ASSIGN:        Process 46.NumberIn=Process 46.NumberIn + 1:
                             Process 46.WIP=Process 46.WIP+1;
3253$         STACK,         1:Save:NEXT(3227$);

3227$         QUEUE,         Process 46.Queue;
3226$         SEIZE,         2,VA:
                             Resource 34,1:NEXT(3225$);

3225$         DELAY:         HoursToBaseTime(expo(10/departurec1# c3,47)),,VA:NEXT(3268$);

3268$         ASSIGN:        Process 46.WaitTime=Process 46.WaitTime + Diff.WaitTime;
3232$         TALLY:         Process 46.WaitTimePerEntity,Diff.WaitTime,1;
3234$         TALLY:         Process 46.TotalTimePerEntity,Diff.StartTime,1;
3258$         ASSIGN:        Process 46.VATime=Process 46.VATime + Diff.VATime;
3259$         TALLY:         Process 46.VATimePerEntity,Diff.VATime,1;
3224$         RELEASE:       Resource 34,1;
3273$         STACK,         1:Destroy:NEXT(3272$);

3272$         ASSIGN:        Process 46.NumberOut=Process 46.NumberOut + 1:
                             Process 46.WIP=Process 46.WIP-1:NEXT(336$);


;
;
;     Model statements for module:  Assign 123
;
336$          ASSIGN:        type=3:NEXT(158$);


;
;
;     Model statements for module:  Assign 129
;
358$          ASSIGN:        departurec2# c3=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,112):NEXT(362$);


;
;
;     Model statements for module:  Decide 171
;
362$          BRANCH,        1:
                             If,departurec2# c3==0,341$,Yes:
                             If,departurec2# c3==1,363$,Yes:
                             Else,364$,Yes;

;
;
;     Model statements for module:  Separate 42
;
364$          DUPLICATE,     100 - 50:
                             departurec2# c3-1,3279$,50:NEXT(3278$);

3278$         ASSIGN:        Separate 42.NumberOut Orig=Separate 42.NumberOut Orig + 1:NEXT(363$);

3279$         ASSIGN:        Separate 42.NumberOut Dup=Separate 42.NumberOut Dup + 1:NEXT(363$);


;
;
;     Model statements for module:  Process 47
;
363$          ASSIGN:        Process 47.NumberIn=Process 47.NumberIn + 1:
                             Process 47.WIP=Process 47.WIP+1;
3309$         STACK,         1:Save:NEXT(3283$);

3283$         QUEUE,         Process 47.Queue;
3282$         SEIZE,         2,VA:
                             Resource 35,1:NEXT(3281$);

3281$         DELAY:         HoursToBaseTime(expo(14/departurec2# c3,48)),,VA:NEXT(3324$);

3324$         ASSIGN:        Process 47.WaitTime=Process 47.WaitTime + Diff.WaitTime;
3288$         TALLY:         Process 47.WaitTimePerEntity,Diff.WaitTime,1;
3290$         TALLY:         Process 47.TotalTimePerEntity,Diff.StartTime,1;
3314$         ASSIGN:        Process 47.VATime=Process 47.VATime + Diff.VATime;
3315$         TALLY:         Process 47.VATimePerEntity,Diff.VATime,1;
3280$         RELEASE:       Resource 35,1;
3329$         STACK,         1:Destroy:NEXT(3328$);

3328$         ASSIGN:        Process 47.NumberOut=Process 47.NumberOut + 1:
                             Process 47.WIP=Process 47.WIP-1:NEXT(336$);


;
;
;     Model statements for module:  Create 57
;

3331$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c3:MinutesToBaseTime(1440):NEXT(3332$);

3332$         ASSIGN:        Create for shipmenta shift2 c3.NumberOut=Create for shipmenta shift2 c3.NumberOut + 1:NEXT(338$);


;
;
;     Model statements for module:  Decide 163
;
338$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3335$,Yes:
                             Else,3336$,Yes;
3335$         ASSIGN:        Decide 163.NumberOut True=Decide 163.NumberOut True + 1:NEXT(337$);

3336$         ASSIGN:        Decide 163.NumberOut False=Decide 163.NumberOut False + 1:NEXT(339$);


;
;
;     Model statements for module:  Assign 124
;
337$          ASSIGN:        departurea1# c3=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,107):NEXT(340$);


;
;
;     Model statements for module:  Decide 164
;
340$          BRANCH,        1:
                             If,departurea1# c3==0,341$,Yes:
                             If,departurea1# c3==1,342$,Yes:
                             Else,343$,Yes;

;
;
;     Model statements for module:  Separate 37
;
343$          DUPLICATE,     100 - 50:
                             departurea1# c3-1,3341$,50:NEXT(3340$);

3340$         ASSIGN:        Separate 37.NumberOut Orig=Separate 37.NumberOut Orig + 1:NEXT(342$);

3341$         ASSIGN:        Separate 37.NumberOut Dup=Separate 37.NumberOut Dup + 1:NEXT(342$);


;
;
;     Model statements for module:  Process 42
;
342$          ASSIGN:        Process 42.NumberIn=Process 42.NumberIn + 1:
                             Process 42.WIP=Process 42.WIP+1;
3371$         STACK,         1:Save:NEXT(3345$);

3345$         QUEUE,         Process 42.Queue;
3344$         SEIZE,         2,VA:
                             Resource 30,1:NEXT(3343$);

3343$         DELAY:         HoursToBaseTime(expo(10/departurea1# c3,43)),,VA:NEXT(3386$);

3386$         ASSIGN:        Process 42.WaitTime=Process 42.WaitTime + Diff.WaitTime;
3350$         TALLY:         Process 42.WaitTimePerEntity,Diff.WaitTime,1;
3352$         TALLY:         Process 42.TotalTimePerEntity,Diff.StartTime,1;
3376$         ASSIGN:        Process 42.VATime=Process 42.VATime + Diff.VATime;
3377$         TALLY:         Process 42.VATimePerEntity,Diff.VATime,1;
3342$         RELEASE:       Resource 30,1;
3391$         STACK,         1:Destroy:NEXT(3390$);

3390$         ASSIGN:        Process 42.NumberOut=Process 42.NumberOut + 1:
                             Process 42.WIP=Process 42.WIP-1:NEXT(334$);


;
;
;     Model statements for module:  Assign 121
;
334$          ASSIGN:        type=1:NEXT(158$);


;
;
;     Model statements for module:  Assign 125
;
339$          ASSIGN:        departurea2# c3=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,108):NEXT(344$);


;
;
;     Model statements for module:  Decide 165
;
344$          BRANCH,        1:
                             If,departurea2# c3==0,341$,Yes:
                             If,departurea2# c3==1,346$,Yes:
                             Else,345$,Yes;

;
;
;     Model statements for module:  Separate 38
;
345$          DUPLICATE,     100 - 50:
                             departurea2# c3-1,3397$,50:NEXT(3396$);

3396$         ASSIGN:        Separate 38.NumberOut Orig=Separate 38.NumberOut Orig + 1:NEXT(346$);

3397$         ASSIGN:        Separate 38.NumberOut Dup=Separate 38.NumberOut Dup + 1:NEXT(346$);


;
;
;     Model statements for module:  Process 43
;
346$          ASSIGN:        Process 43.NumberIn=Process 43.NumberIn + 1:
                             Process 43.WIP=Process 43.WIP+1;
3427$         STACK,         1:Save:NEXT(3401$);

3401$         QUEUE,         Process 43.Queue;
3400$         SEIZE,         2,VA:
                             Resource 31,1:NEXT(3399$);

3399$         DELAY:         HoursToBaseTime(expo(14/departurea2# c3,44)),,VA:NEXT(3442$);

3442$         ASSIGN:        Process 43.WaitTime=Process 43.WaitTime + Diff.WaitTime;
3406$         TALLY:         Process 43.WaitTimePerEntity,Diff.WaitTime,1;
3408$         TALLY:         Process 43.TotalTimePerEntity,Diff.StartTime,1;
3432$         ASSIGN:        Process 43.VATime=Process 43.VATime + Diff.VATime;
3433$         TALLY:         Process 43.VATimePerEntity,Diff.VATime,1;
3398$         RELEASE:       Resource 31,1;
3447$         STACK,         1:Destroy:NEXT(3446$);

3446$         ASSIGN:        Process 43.NumberOut=Process 43.NumberOut + 1:
                             Process 43.WIP=Process 43.WIP-1:NEXT(334$);


;
;
;     Model statements for module:  Create 58
;

3449$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c3:MinutesToBaseTime(1440):NEXT(3450$);

3450$         ASSIGN:        Create for shipment b shift2 c3.NumberOut=Create for shipment b shift2 c3.NumberOut + 1:NEXT(347$);


;
;
;     Model statements for module:  Create 60
;

3453$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c4:MinutesToBaseTime(1440):NEXT(3454$);

3454$         ASSIGN:        Create for receiving b shift1 c4.NumberOut=Create for receiving b shift1 c4.NumberOut + 1
                             :NEXT(378$);


;
;
;     Model statements for module:  Decide 175
;
378$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3457$,Yes:
                             Else,3458$,Yes;
3457$         ASSIGN:        Decide 175.NumberOut True=Decide 175.NumberOut True + 1:NEXT(379$);

3458$         ASSIGN:        Decide 175.NumberOut False=Decide 175.NumberOut False + 1:NEXT(380$);


;
;
;     Model statements for module:  Assign 135
;
379$          ASSIGN:        receiptb1# c4=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,85)
                             :NEXT(381$);


;
;
;     Model statements for module:  Decide 176
;
381$          BRANCH,        1:
                             If,receiptb1# c4==0,370$,Yes:
                             If,receiptb1# c4==1,382$,Yes:
                             Else,383$,Yes;

;
;
;     Model statements for module:  Separate 45
;
383$          DUPLICATE,     100 - 50:
                             receiptb1# c4-1,3463$,50:NEXT(3462$);

3462$         ASSIGN:        Separate 45.NumberOut Orig=Separate 45.NumberOut Orig + 1:NEXT(382$);

3463$         ASSIGN:        Separate 45.NumberOut Dup=Separate 45.NumberOut Dup + 1:NEXT(382$);


;
;
;     Model statements for module:  Process 50
;
382$          ASSIGN:        Process 50.NumberIn=Process 50.NumberIn + 1:
                             Process 50.WIP=Process 50.WIP+1;
3493$         STACK,         1:Save:NEXT(3467$);

3467$         QUEUE,         Process 50.Queue;
3466$         SEIZE,         2,VA:
                             Resource 38,1:NEXT(3465$);

3465$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c4,21)),,VA:NEXT(3508$);

3508$         ASSIGN:        Process 50.WaitTime=Process 50.WaitTime + Diff.WaitTime;
3472$         TALLY:         Process 50.WaitTimePerEntity,Diff.WaitTime,1;
3474$         TALLY:         Process 50.TotalTimePerEntity,Diff.StartTime,1;
3498$         ASSIGN:        Process 50.VATime=Process 50.VATime + Diff.VATime;
3499$         TALLY:         Process 50.VATimePerEntity,Diff.VATime,1;
3464$         RELEASE:       Resource 38,1;
3513$         STACK,         1:Destroy:NEXT(3512$);

3512$         ASSIGN:        Process 50.NumberOut=Process 50.NumberOut + 1:
                             Process 50.WIP=Process 50.WIP-1:NEXT(366$);


;
;
;     Model statements for module:  Assign 131
;
366$          ASSIGN:        producttype=2:NEXT(180$);


;
;
;     Model statements for module:  Dispose 27
;
370$          ASSIGN:        Dispose 27.NumberOut=Dispose 27.NumberOut + 1;
3515$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 136
;
380$          ASSIGN:        receiptb2# c4=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,86)
                             :NEXT(384$);


;
;
;     Model statements for module:  Decide 177
;
384$          BRANCH,        1:
                             If,receiptb2# c4==0,370$,Yes:
                             If,receiptb2# c4==1,385$,Yes:
                             Else,386$,Yes;

;
;
;     Model statements for module:  Separate 46
;
386$          DUPLICATE,     100 - 50:
                             receiptb2# c4-1,3520$,50:NEXT(3519$);

3519$         ASSIGN:        Separate 46.NumberOut Orig=Separate 46.NumberOut Orig + 1:NEXT(385$);

3520$         ASSIGN:        Separate 46.NumberOut Dup=Separate 46.NumberOut Dup + 1:NEXT(385$);


;
;
;     Model statements for module:  Process 51
;
385$          ASSIGN:        Process 51.NumberIn=Process 51.NumberIn + 1:
                             Process 51.WIP=Process 51.WIP+1;
3550$         STACK,         1:Save:NEXT(3524$);

3524$         QUEUE,         Process 51.Queue;
3523$         SEIZE,         2,VA:
                             Resource 39,1:NEXT(3522$);

3522$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c4,22)),,VA:NEXT(3565$);

3565$         ASSIGN:        Process 51.WaitTime=Process 51.WaitTime + Diff.WaitTime;
3529$         TALLY:         Process 51.WaitTimePerEntity,Diff.WaitTime,1;
3531$         TALLY:         Process 51.TotalTimePerEntity,Diff.StartTime,1;
3555$         ASSIGN:        Process 51.VATime=Process 51.VATime + Diff.VATime;
3556$         TALLY:         Process 51.VATimePerEntity,Diff.VATime,1;
3521$         RELEASE:       Resource 39,1;
3570$         STACK,         1:Destroy:NEXT(3569$);

3569$         ASSIGN:        Process 51.NumberOut=Process 51.NumberOut + 1:
                             Process 51.WIP=Process 51.WIP-1:NEXT(366$);


;
;
;     Model statements for module:  Create 61
;

3572$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c4:MinutesToBaseTime(1440):NEXT(3573$);

3573$         ASSIGN:        Create for receiving c shift1 c4.NumberOut=Create for receiving c shift1 c4.NumberOut + 1
                             :NEXT(387$);


;
;
;     Model statements for module:  Decide 178
;
387$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3576$,Yes:
                             Else,3577$,Yes;
3576$         ASSIGN:        Decide 178.NumberOut True=Decide 178.NumberOut True + 1:NEXT(388$);

3577$         ASSIGN:        Decide 178.NumberOut False=Decide 178.NumberOut False + 1:NEXT(389$);


;
;
;     Model statements for module:  Assign 137
;
388$          ASSIGN:        receiptc1# c4=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,87)
                             :NEXT(390$);


;
;
;     Model statements for module:  Decide 179
;
390$          BRANCH,        1:
                             If,receiptc1# c4==0,370$,Yes:
                             If,receiptc1# c4==1,391$,Yes:
                             Else,392$,Yes;

;
;
;     Model statements for module:  Separate 47
;
392$          DUPLICATE,     100 - 50:
                             receiptc1# c4-1,3582$,50:NEXT(3581$);

3581$         ASSIGN:        Separate 47.NumberOut Orig=Separate 47.NumberOut Orig + 1:NEXT(391$);

3582$         ASSIGN:        Separate 47.NumberOut Dup=Separate 47.NumberOut Dup + 1:NEXT(391$);


;
;
;     Model statements for module:  Process 52
;
391$          ASSIGN:        Process 52.NumberIn=Process 52.NumberIn + 1:
                             Process 52.WIP=Process 52.WIP+1;
3612$         STACK,         1:Save:NEXT(3586$);

3586$         QUEUE,         Process 52.Queue;
3585$         SEIZE,         2,VA:
                             Resource 40,1:NEXT(3584$);

3584$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c4,23)),,VA:NEXT(3627$);

3627$         ASSIGN:        Process 52.WaitTime=Process 52.WaitTime + Diff.WaitTime;
3591$         TALLY:         Process 52.WaitTimePerEntity,Diff.WaitTime,1;
3593$         TALLY:         Process 52.TotalTimePerEntity,Diff.StartTime,1;
3617$         ASSIGN:        Process 52.VATime=Process 52.VATime + Diff.VATime;
3618$         TALLY:         Process 52.VATimePerEntity,Diff.VATime,1;
3583$         RELEASE:       Resource 40,1;
3632$         STACK,         1:Destroy:NEXT(3631$);

3631$         ASSIGN:        Process 52.NumberOut=Process 52.NumberOut + 1:
                             Process 52.WIP=Process 52.WIP-1:NEXT(367$);


;
;
;     Model statements for module:  Assign 132
;
367$          ASSIGN:        producttype=3:NEXT(180$);


;
;
;     Model statements for module:  Assign 138
;
389$          ASSIGN:        receiptc2# c4=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,88)
                             :NEXT(393$);


;
;
;     Model statements for module:  Decide 180
;
393$          BRANCH,        1:
                             If,receiptc2# c4==0,370$,Yes:
                             If,receiptc2# c4==1,394$,Yes:
                             Else,395$,Yes;

;
;
;     Model statements for module:  Separate 48
;
395$          DUPLICATE,     100 - 50:
                             receiptc2# c4-1,3638$,50:NEXT(3637$);

3637$         ASSIGN:        Separate 48.NumberOut Orig=Separate 48.NumberOut Orig + 1:NEXT(394$);

3638$         ASSIGN:        Separate 48.NumberOut Dup=Separate 48.NumberOut Dup + 1:NEXT(394$);


;
;
;     Model statements for module:  Process 53
;
394$          ASSIGN:        Process 53.NumberIn=Process 53.NumberIn + 1:
                             Process 53.WIP=Process 53.WIP+1;
3668$         STACK,         1:Save:NEXT(3642$);

3642$         QUEUE,         Process 53.Queue;
3641$         SEIZE,         2,VA:
                             Resource 41,1:NEXT(3640$);

3640$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c4,24)),,VA:NEXT(3683$);

3683$         ASSIGN:        Process 53.WaitTime=Process 53.WaitTime + Diff.WaitTime;
3647$         TALLY:         Process 53.WaitTimePerEntity,Diff.WaitTime,1;
3649$         TALLY:         Process 53.TotalTimePerEntity,Diff.StartTime,1;
3673$         ASSIGN:        Process 53.VATime=Process 53.VATime + Diff.VATime;
3674$         TALLY:         Process 53.VATimePerEntity,Diff.VATime,1;
3639$         RELEASE:       Resource 41,1;
3688$         STACK,         1:Destroy:NEXT(3687$);

3687$         ASSIGN:        Process 53.NumberOut=Process 53.NumberOut + 1:
                             Process 53.WIP=Process 53.WIP-1:NEXT(367$);


;
;
;     Model statements for module:  Create 63
;

3690$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c4:MinutesToBaseTime(1440):NEXT(3691$);

3691$         ASSIGN:        Create for receiving a shift2 c4.NumberOut=Create for receiving a shift2 c4.NumberOut + 1
                             :NEXT(373$);


;
;
;     Model statements for module:  Decide 173
;
373$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3694$,Yes:
                             Else,3695$,Yes;
3694$         ASSIGN:        Decide 173.NumberOut True=Decide 173.NumberOut True + 1:NEXT(368$);

3695$         ASSIGN:        Decide 173.NumberOut False=Decide 173.NumberOut False + 1:NEXT(374$);


;
;
;     Model statements for module:  Assign 133
;
368$          ASSIGN:        receipta1# c4=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,83)
                             :NEXT(369$);


;
;
;     Model statements for module:  Decide 172
;
369$          BRANCH,        1:
                             If,receipta1# c4==0,370$,Yes:
                             If,receipta1# c4==1,371$,Yes:
                             Else,372$,Yes;

;
;
;     Model statements for module:  Separate 43
;
372$          DUPLICATE,     100 - 50:
                             receipta1# c4-1,3700$,50:NEXT(3699$);

3699$         ASSIGN:        Separate 43.NumberOut Orig=Separate 43.NumberOut Orig + 1:NEXT(371$);

3700$         ASSIGN:        Separate 43.NumberOut Dup=Separate 43.NumberOut Dup + 1:NEXT(371$);


;
;
;     Model statements for module:  Process 48
;
371$          ASSIGN:        Process 48.NumberIn=Process 48.NumberIn + 1:
                             Process 48.WIP=Process 48.WIP+1;
3730$         STACK,         1:Save:NEXT(3704$);

3704$         QUEUE,         Process 48.Queue;
3703$         SEIZE,         2,VA:
                             Resource 36,1:NEXT(3702$);

3702$         DELAY:         HoursToBaseTime(expo(10/receipta1# c4,19)),,VA:NEXT(3745$);

3745$         ASSIGN:        Process 48.WaitTime=Process 48.WaitTime + Diff.WaitTime;
3709$         TALLY:         Process 48.WaitTimePerEntity,Diff.WaitTime,1;
3711$         TALLY:         Process 48.TotalTimePerEntity,Diff.StartTime,1;
3735$         ASSIGN:        Process 48.VATime=Process 48.VATime + Diff.VATime;
3736$         TALLY:         Process 48.VATimePerEntity,Diff.VATime,1;
3701$         RELEASE:       Resource 36,1;
3750$         STACK,         1:Destroy:NEXT(3749$);

3749$         ASSIGN:        Process 48.NumberOut=Process 48.NumberOut + 1:
                             Process 48.WIP=Process 48.WIP-1:NEXT(365$);


;
;
;     Model statements for module:  Assign 130
;
365$          ASSIGN:        producttype=1:NEXT(180$);


;
;
;     Model statements for module:  Assign 134
;
374$          ASSIGN:        receipta2# c4=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,84)
                             :NEXT(375$);


;
;
;     Model statements for module:  Decide 174
;
375$          BRANCH,        1:
                             If,receipta2# c4==0,370$,Yes:
                             If,receipta2# c4==1,377$,Yes:
                             Else,376$,Yes;

;
;
;     Model statements for module:  Separate 44
;
376$          DUPLICATE,     100 - 50:
                             receipta2# c4-1,3756$,50:NEXT(3755$);

3755$         ASSIGN:        Separate 44.NumberOut Orig=Separate 44.NumberOut Orig + 1:NEXT(377$);

3756$         ASSIGN:        Separate 44.NumberOut Dup=Separate 44.NumberOut Dup + 1:NEXT(377$);


;
;
;     Model statements for module:  Process 49
;
377$          ASSIGN:        Process 49.NumberIn=Process 49.NumberIn + 1:
                             Process 49.WIP=Process 49.WIP+1;
3786$         STACK,         1:Save:NEXT(3760$);

3760$         QUEUE,         Process 49.Queue;
3759$         SEIZE,         2,VA:
                             Resource 37,1:NEXT(3758$);

3758$         DELAY:         HoursToBaseTime(expo(14/receipta2# c4,20)),,VA:NEXT(3801$);

3801$         ASSIGN:        Process 49.WaitTime=Process 49.WaitTime + Diff.WaitTime;
3765$         TALLY:         Process 49.WaitTimePerEntity,Diff.WaitTime,1;
3767$         TALLY:         Process 49.TotalTimePerEntity,Diff.StartTime,1;
3791$         ASSIGN:        Process 49.VATime=Process 49.VATime + Diff.VATime;
3792$         TALLY:         Process 49.VATimePerEntity,Diff.VATime,1;
3757$         RELEASE:       Resource 37,1;
3806$         STACK,         1:Destroy:NEXT(3805$);

3805$         ASSIGN:        Process 49.NumberOut=Process 49.NumberOut + 1:
                             Process 49.WIP=Process 49.WIP-1:NEXT(365$);


;
;
;     Model statements for module:  Create 64
;

3808$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c4:MinutesToBaseTime(1440):NEXT(3809$);

3809$         ASSIGN:        Create for receiving b shift2 c4.NumberOut=Create for receiving b shift2 c4.NumberOut + 1
                             :NEXT(378$);


;
;
;     Model statements for module:  Create 65
;

3812$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c4:MinutesToBaseTime(1440):NEXT(3813$);

3813$         ASSIGN:        Create for receiving c shift2 c4.NumberOut=Create for receiving c shift2 c4.NumberOut + 1
                             :NEXT(387$);


;
;
;     Model statements for module:  Create 69
;

3816$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c4:MinutesToBaseTime(1440):NEXT(3817$);

3817$         ASSIGN:        Create for shipment b shift1 c4.NumberOut=Create for shipment b shift1 c4.NumberOut + 1:NEXT(409$);


;
;
;     Model statements for module:  Decide 184
;
409$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3820$,Yes:
                             Else,3821$,Yes;
3820$         ASSIGN:        Decide 184.NumberOut True=Decide 184.NumberOut True + 1:NEXT(410$);

3821$         ASSIGN:        Decide 184.NumberOut False=Decide 184.NumberOut False + 1:NEXT(411$);


;
;
;     Model statements for module:  Assign 144
;
410$          ASSIGN:        departureb1# c4=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,115):NEXT(412$);


;
;
;     Model statements for module:  Decide 185
;
412$          BRANCH,        1:
                             If,departureb1# c4==0,403$,Yes:
                             If,departureb1# c4==1,413$,Yes:
                             Else,414$,Yes;

;
;
;     Model statements for module:  Separate 51
;
414$          DUPLICATE,     100 - 50:
                             departureb1# c4-1,3826$,50:NEXT(3825$);

3825$         ASSIGN:        Separate 51.NumberOut Orig=Separate 51.NumberOut Orig + 1:NEXT(413$);

3826$         ASSIGN:        Separate 51.NumberOut Dup=Separate 51.NumberOut Dup + 1:NEXT(413$);


;
;
;     Model statements for module:  Process 56
;
413$          ASSIGN:        Process 56.NumberIn=Process 56.NumberIn + 1:
                             Process 56.WIP=Process 56.WIP+1;
3856$         STACK,         1:Save:NEXT(3830$);

3830$         QUEUE,         Process 56.Queue;
3829$         SEIZE,         2,VA:
                             Resource 44,1:NEXT(3828$);

3828$         DELAY:         HoursToBaseTime(expo(10/departureb1# c4,51)),,VA:NEXT(3871$);

3871$         ASSIGN:        Process 56.WaitTime=Process 56.WaitTime + Diff.WaitTime;
3835$         TALLY:         Process 56.WaitTimePerEntity,Diff.WaitTime,1;
3837$         TALLY:         Process 56.TotalTimePerEntity,Diff.StartTime,1;
3861$         ASSIGN:        Process 56.VATime=Process 56.VATime + Diff.VATime;
3862$         TALLY:         Process 56.VATimePerEntity,Diff.VATime,1;
3827$         RELEASE:       Resource 44,1;
3876$         STACK,         1:Destroy:NEXT(3875$);

3875$         ASSIGN:        Process 56.NumberOut=Process 56.NumberOut + 1:
                             Process 56.WIP=Process 56.WIP-1:NEXT(397$);


;
;
;     Model statements for module:  Assign 140
;
397$          ASSIGN:        type=2:NEXT(158$);


;
;
;     Model statements for module:  Dispose 28
;
403$          ASSIGN:        Dispose 28.NumberOut=Dispose 28.NumberOut + 1;
3878$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 145
;
411$          ASSIGN:        departureb2# c4=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,116)
                             :NEXT(415$);


;
;
;     Model statements for module:  Decide 186
;
415$          BRANCH,        1:
                             If,departureb2# c4==0,403$,Yes:
                             If,departureb2# c4==1,416$,Yes:
                             Else,417$,Yes;

;
;
;     Model statements for module:  Separate 52
;
417$          DUPLICATE,     100 - 50:
                             departureb2# c4-1,3883$,50:NEXT(3882$);

3882$         ASSIGN:        Separate 52.NumberOut Orig=Separate 52.NumberOut Orig + 1:NEXT(416$);

3883$         ASSIGN:        Separate 52.NumberOut Dup=Separate 52.NumberOut Dup + 1:NEXT(416$);


;
;
;     Model statements for module:  Process 57
;
416$          ASSIGN:        Process 57.NumberIn=Process 57.NumberIn + 1:
                             Process 57.WIP=Process 57.WIP+1;
3913$         STACK,         1:Save:NEXT(3887$);

3887$         QUEUE,         Process 57.Queue;
3886$         SEIZE,         2,VA:
                             Resource 45,1:NEXT(3885$);

3885$         DELAY:         HoursToBaseTime(expo(14/departureb2# c4,52)),,VA:NEXT(3928$);

3928$         ASSIGN:        Process 57.WaitTime=Process 57.WaitTime + Diff.WaitTime;
3892$         TALLY:         Process 57.WaitTimePerEntity,Diff.WaitTime,1;
3894$         TALLY:         Process 57.TotalTimePerEntity,Diff.StartTime,1;
3918$         ASSIGN:        Process 57.VATime=Process 57.VATime + Diff.VATime;
3919$         TALLY:         Process 57.VATimePerEntity,Diff.VATime,1;
3884$         RELEASE:       Resource 45,1;
3933$         STACK,         1:Destroy:NEXT(3932$);

3932$         ASSIGN:        Process 57.NumberOut=Process 57.NumberOut + 1:
                             Process 57.WIP=Process 57.WIP-1:NEXT(397$);


;
;
;     Model statements for module:  Create 70
;

3935$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c4:MinutesToBaseTime(1440):NEXT(3936$);

3936$         ASSIGN:        Create for shipment c shift1 c4.NumberOut=Create for shipment c shift1 c4.NumberOut + 1:NEXT(418$);


;
;
;     Model statements for module:  Decide 187
;
418$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3939$,Yes:
                             Else,3940$,Yes;
3939$         ASSIGN:        Decide 187.NumberOut True=Decide 187.NumberOut True + 1:NEXT(419$);

3940$         ASSIGN:        Decide 187.NumberOut False=Decide 187.NumberOut False + 1:NEXT(420$);


;
;
;     Model statements for module:  Assign 146
;
419$          ASSIGN:        departurec1# c4=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,117):NEXT(421$);


;
;
;     Model statements for module:  Decide 188
;
421$          BRANCH,        1:
                             If,departurec1# c4==0,403$,Yes:
                             If,departurec1# c4==1,422$,Yes:
                             Else,423$,Yes;

;
;
;     Model statements for module:  Separate 53
;
423$          DUPLICATE,     100 - 50:
                             departurec1# c4-1,3945$,50:NEXT(3944$);

3944$         ASSIGN:        Separate 53.NumberOut Orig=Separate 53.NumberOut Orig + 1:NEXT(422$);

3945$         ASSIGN:        Separate 53.NumberOut Dup=Separate 53.NumberOut Dup + 1:NEXT(422$);


;
;
;     Model statements for module:  Process 58
;
422$          ASSIGN:        Process 58.NumberIn=Process 58.NumberIn + 1:
                             Process 58.WIP=Process 58.WIP+1;
3975$         STACK,         1:Save:NEXT(3949$);

3949$         QUEUE,         Process 58.Queue;
3948$         SEIZE,         2,VA:
                             Resource 46,1:NEXT(3947$);

3947$         DELAY:         HoursToBaseTime(expo(10/departurec1# c4,53)),,VA:NEXT(3990$);

3990$         ASSIGN:        Process 58.WaitTime=Process 58.WaitTime + Diff.WaitTime;
3954$         TALLY:         Process 58.WaitTimePerEntity,Diff.WaitTime,1;
3956$         TALLY:         Process 58.TotalTimePerEntity,Diff.StartTime,1;
3980$         ASSIGN:        Process 58.VATime=Process 58.VATime + Diff.VATime;
3981$         TALLY:         Process 58.VATimePerEntity,Diff.VATime,1;
3946$         RELEASE:       Resource 46,1;
3995$         STACK,         1:Destroy:NEXT(3994$);

3994$         ASSIGN:        Process 58.NumberOut=Process 58.NumberOut + 1:
                             Process 58.WIP=Process 58.WIP-1:NEXT(398$);


;
;
;     Model statements for module:  Assign 141
;
398$          ASSIGN:        type=3:NEXT(158$);


;
;
;     Model statements for module:  Assign 147
;
420$          ASSIGN:        departurec2# c4=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,118):NEXT(424$);


;
;
;     Model statements for module:  Decide 189
;
424$          BRANCH,        1:
                             If,departurec2# c4==0,403$,Yes:
                             If,departurec2# c4==1,425$,Yes:
                             Else,426$,Yes;

;
;
;     Model statements for module:  Separate 54
;
426$          DUPLICATE,     100 - 50:
                             departurec2# c4-1,4001$,50:NEXT(4000$);

4000$         ASSIGN:        Separate 54.NumberOut Orig=Separate 54.NumberOut Orig + 1:NEXT(425$);

4001$         ASSIGN:        Separate 54.NumberOut Dup=Separate 54.NumberOut Dup + 1:NEXT(425$);


;
;
;     Model statements for module:  Process 59
;
425$          ASSIGN:        Process 59.NumberIn=Process 59.NumberIn + 1:
                             Process 59.WIP=Process 59.WIP+1;
4031$         STACK,         1:Save:NEXT(4005$);

4005$         QUEUE,         Process 59.Queue;
4004$         SEIZE,         2,VA:
                             Resource 47,1:NEXT(4003$);

4003$         DELAY:         HoursToBaseTime(expo(14/departurec2# c4,54)),,VA:NEXT(4046$);

4046$         ASSIGN:        Process 59.WaitTime=Process 59.WaitTime + Diff.WaitTime;
4010$         TALLY:         Process 59.WaitTimePerEntity,Diff.WaitTime,1;
4012$         TALLY:         Process 59.TotalTimePerEntity,Diff.StartTime,1;
4036$         ASSIGN:        Process 59.VATime=Process 59.VATime + Diff.VATime;
4037$         TALLY:         Process 59.VATimePerEntity,Diff.VATime,1;
4002$         RELEASE:       Resource 47,1;
4051$         STACK,         1:Destroy:NEXT(4050$);

4050$         ASSIGN:        Process 59.NumberOut=Process 59.NumberOut + 1:
                             Process 59.WIP=Process 59.WIP-1:NEXT(398$);


;
;
;     Model statements for module:  Create 72
;

4053$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c4:MinutesToBaseTime(1440):NEXT(4054$);

4054$         ASSIGN:        Create for shipmenta shift2 c4.NumberOut=Create for shipmenta shift2 c4.NumberOut + 1:NEXT(400$);


;
;
;     Model statements for module:  Decide 181
;
400$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4057$,Yes:
                             Else,4058$,Yes;
4057$         ASSIGN:        Decide 181.NumberOut True=Decide 181.NumberOut True + 1:NEXT(399$);

4058$         ASSIGN:        Decide 181.NumberOut False=Decide 181.NumberOut False + 1:NEXT(401$);


;
;
;     Model statements for module:  Assign 142
;
399$          ASSIGN:        departurea1# c4=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,113):NEXT(402$);


;
;
;     Model statements for module:  Decide 182
;
402$          BRANCH,        1:
                             If,departurea1# c4==0,403$,Yes:
                             If,departurea1# c4==1,404$,Yes:
                             Else,405$,Yes;

;
;
;     Model statements for module:  Separate 49
;
405$          DUPLICATE,     100 - 50:
                             departurea1# c4-1,4063$,50:NEXT(4062$);

4062$         ASSIGN:        Separate 49.NumberOut Orig=Separate 49.NumberOut Orig + 1:NEXT(404$);

4063$         ASSIGN:        Separate 49.NumberOut Dup=Separate 49.NumberOut Dup + 1:NEXT(404$);


;
;
;     Model statements for module:  Process 54
;
404$          ASSIGN:        Process 54.NumberIn=Process 54.NumberIn + 1:
                             Process 54.WIP=Process 54.WIP+1;
4093$         STACK,         1:Save:NEXT(4067$);

4067$         QUEUE,         Process 54.Queue;
4066$         SEIZE,         2,VA:
                             Resource 42,1:NEXT(4065$);

4065$         DELAY:         HoursToBaseTime(expo(10/departurea1# c4,49)),,VA:NEXT(4108$);

4108$         ASSIGN:        Process 54.WaitTime=Process 54.WaitTime + Diff.WaitTime;
4072$         TALLY:         Process 54.WaitTimePerEntity,Diff.WaitTime,1;
4074$         TALLY:         Process 54.TotalTimePerEntity,Diff.StartTime,1;
4098$         ASSIGN:        Process 54.VATime=Process 54.VATime + Diff.VATime;
4099$         TALLY:         Process 54.VATimePerEntity,Diff.VATime,1;
4064$         RELEASE:       Resource 42,1;
4113$         STACK,         1:Destroy:NEXT(4112$);

4112$         ASSIGN:        Process 54.NumberOut=Process 54.NumberOut + 1:
                             Process 54.WIP=Process 54.WIP-1:NEXT(396$);


;
;
;     Model statements for module:  Assign 139
;
396$          ASSIGN:        type=1:NEXT(158$);


;
;
;     Model statements for module:  Assign 143
;
401$          ASSIGN:        departurea2# c4=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,114):NEXT(406$);


;
;
;     Model statements for module:  Decide 183
;
406$          BRANCH,        1:
                             If,departurea2# c4==0,403$,Yes:
                             If,departurea2# c4==1,408$,Yes:
                             Else,407$,Yes;

;
;
;     Model statements for module:  Separate 50
;
407$          DUPLICATE,     100 - 50:
                             departurea2# c4-1,4119$,50:NEXT(4118$);

4118$         ASSIGN:        Separate 50.NumberOut Orig=Separate 50.NumberOut Orig + 1:NEXT(408$);

4119$         ASSIGN:        Separate 50.NumberOut Dup=Separate 50.NumberOut Dup + 1:NEXT(408$);


;
;
;     Model statements for module:  Process 55
;
408$          ASSIGN:        Process 55.NumberIn=Process 55.NumberIn + 1:
                             Process 55.WIP=Process 55.WIP+1;
4149$         STACK,         1:Save:NEXT(4123$);

4123$         QUEUE,         Process 55.Queue;
4122$         SEIZE,         2,VA:
                             Resource 43,1:NEXT(4121$);

4121$         DELAY:         HoursToBaseTime(expo(14/departurea2# c4,50)),,VA:NEXT(4164$);

4164$         ASSIGN:        Process 55.WaitTime=Process 55.WaitTime + Diff.WaitTime;
4128$         TALLY:         Process 55.WaitTimePerEntity,Diff.WaitTime,1;
4130$         TALLY:         Process 55.TotalTimePerEntity,Diff.StartTime,1;
4154$         ASSIGN:        Process 55.VATime=Process 55.VATime + Diff.VATime;
4155$         TALLY:         Process 55.VATimePerEntity,Diff.VATime,1;
4120$         RELEASE:       Resource 43,1;
4169$         STACK,         1:Destroy:NEXT(4168$);

4168$         ASSIGN:        Process 55.NumberOut=Process 55.NumberOut + 1:
                             Process 55.WIP=Process 55.WIP-1:NEXT(396$);


;
;
;     Model statements for module:  Create 73
;

4171$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c4:MinutesToBaseTime(1440):NEXT(4172$);

4172$         ASSIGN:        Create for shipment b shift2 c4.NumberOut=Create for shipment b shift2 c4.NumberOut + 1:NEXT(409$);


;
;
;     Model statements for module:  Create 84
;

4175$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c5:MinutesToBaseTime(1440):NEXT(4176$);

4176$         ASSIGN:        Create for receiving b shift1 c5.NumberOut=Create for receiving b shift1 c5.NumberOut + 1
                             :NEXT(440$);


;
;
;     Model statements for module:  Decide 202
;
440$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4179$,Yes:
                             Else,4180$,Yes;
4179$         ASSIGN:        Decide 202.NumberOut True=Decide 202.NumberOut True + 1:NEXT(441$);

4180$         ASSIGN:        Decide 202.NumberOut False=Decide 202.NumberOut False + 1:NEXT(442$);


;
;
;     Model statements for module:  Assign 162
;
441$          ASSIGN:        receiptb1# c5=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,91)
                             :NEXT(443$);


;
;
;     Model statements for module:  Decide 203
;
443$          BRANCH,        1:
                             If,receiptb1# c5==0,432$,Yes:
                             If,receiptb1# c5==1,444$,Yes:
                             Else,445$,Yes;

;
;
;     Model statements for module:  Separate 63
;
445$          DUPLICATE,     100 - 50:
                             receiptb1# c5-1,4185$,50:NEXT(4184$);

4184$         ASSIGN:        Separate 63.NumberOut Orig=Separate 63.NumberOut Orig + 1:NEXT(444$);

4185$         ASSIGN:        Separate 63.NumberOut Dup=Separate 63.NumberOut Dup + 1:NEXT(444$);


;
;
;     Model statements for module:  Process 68
;
444$          ASSIGN:        Process 68.NumberIn=Process 68.NumberIn + 1:
                             Process 68.WIP=Process 68.WIP+1;
4215$         STACK,         1:Save:NEXT(4189$);

4189$         QUEUE,         Process 68.Queue;
4188$         SEIZE,         2,VA:
                             Resource 50,1:NEXT(4187$);

4187$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c5,27)),,VA:NEXT(4230$);

4230$         ASSIGN:        Process 68.WaitTime=Process 68.WaitTime + Diff.WaitTime;
4194$         TALLY:         Process 68.WaitTimePerEntity,Diff.WaitTime,1;
4196$         TALLY:         Process 68.TotalTimePerEntity,Diff.StartTime,1;
4220$         ASSIGN:        Process 68.VATime=Process 68.VATime + Diff.VATime;
4221$         TALLY:         Process 68.VATimePerEntity,Diff.VATime,1;
4186$         RELEASE:       Resource 50,1;
4235$         STACK,         1:Destroy:NEXT(4234$);

4234$         ASSIGN:        Process 68.NumberOut=Process 68.NumberOut + 1:
                             Process 68.WIP=Process 68.WIP-1:NEXT(428$);


;
;
;     Model statements for module:  Assign 158
;
428$          ASSIGN:        producttype=2:NEXT(180$);


;
;
;     Model statements for module:  Dispose 30
;
432$          ASSIGN:        Dispose 30.NumberOut=Dispose 30.NumberOut + 1;
4237$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 163
;
442$          ASSIGN:        receiptb2# c5=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,92)
                             :NEXT(446$);


;
;
;     Model statements for module:  Decide 204
;
446$          BRANCH,        1:
                             If,receiptb2# c5==0,432$,Yes:
                             If,receiptb2# c5==1,447$,Yes:
                             Else,448$,Yes;

;
;
;     Model statements for module:  Separate 64
;
448$          DUPLICATE,     100 - 50:
                             receiptb2# c5-1,4242$,50:NEXT(4241$);

4241$         ASSIGN:        Separate 64.NumberOut Orig=Separate 64.NumberOut Orig + 1:NEXT(447$);

4242$         ASSIGN:        Separate 64.NumberOut Dup=Separate 64.NumberOut Dup + 1:NEXT(447$);


;
;
;     Model statements for module:  Process 69
;
447$          ASSIGN:        Process 69.NumberIn=Process 69.NumberIn + 1:
                             Process 69.WIP=Process 69.WIP+1;
4272$         STACK,         1:Save:NEXT(4246$);

4246$         QUEUE,         Process 69.Queue;
4245$         SEIZE,         2,VA:
                             Resource 51,1:NEXT(4244$);

4244$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c5,28)),,VA:NEXT(4287$);

4287$         ASSIGN:        Process 69.WaitTime=Process 69.WaitTime + Diff.WaitTime;
4251$         TALLY:         Process 69.WaitTimePerEntity,Diff.WaitTime,1;
4253$         TALLY:         Process 69.TotalTimePerEntity,Diff.StartTime,1;
4277$         ASSIGN:        Process 69.VATime=Process 69.VATime + Diff.VATime;
4278$         TALLY:         Process 69.VATimePerEntity,Diff.VATime,1;
4243$         RELEASE:       Resource 51,1;
4292$         STACK,         1:Destroy:NEXT(4291$);

4291$         ASSIGN:        Process 69.NumberOut=Process 69.NumberOut + 1:
                             Process 69.WIP=Process 69.WIP-1:NEXT(428$);


;
;
;     Model statements for module:  Create 85
;

4294$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c5:MinutesToBaseTime(1440):NEXT(4295$);

4295$         ASSIGN:        Create for receiving c shift1 c5.NumberOut=Create for receiving c shift1 c5.NumberOut + 1
                             :NEXT(449$);


;
;
;     Model statements for module:  Decide 205
;
449$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4298$,Yes:
                             Else,4299$,Yes;
4298$         ASSIGN:        Decide 205.NumberOut True=Decide 205.NumberOut True + 1:NEXT(450$);

4299$         ASSIGN:        Decide 205.NumberOut False=Decide 205.NumberOut False + 1:NEXT(451$);


;
;
;     Model statements for module:  Assign 164
;
450$          ASSIGN:        receiptc1# c5=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,93)
                             :NEXT(452$);


;
;
;     Model statements for module:  Decide 206
;
452$          BRANCH,        1:
                             If,receiptc1# c5==0,432$,Yes:
                             If,receiptc1# c5==1,453$,Yes:
                             Else,454$,Yes;

;
;
;     Model statements for module:  Separate 65
;
454$          DUPLICATE,     100 - 50:
                             receiptc1# c5-1,4304$,50:NEXT(4303$);

4303$         ASSIGN:        Separate 65.NumberOut Orig=Separate 65.NumberOut Orig + 1:NEXT(453$);

4304$         ASSIGN:        Separate 65.NumberOut Dup=Separate 65.NumberOut Dup + 1:NEXT(453$);


;
;
;     Model statements for module:  Process 70
;
453$          ASSIGN:        Process 70.NumberIn=Process 70.NumberIn + 1:
                             Process 70.WIP=Process 70.WIP+1;
4334$         STACK,         1:Save:NEXT(4308$);

4308$         QUEUE,         Process 70.Queue;
4307$         SEIZE,         2,VA:
                             Resource 52,1:NEXT(4306$);

4306$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c5,29)),,VA:NEXT(4349$);

4349$         ASSIGN:        Process 70.WaitTime=Process 70.WaitTime + Diff.WaitTime;
4313$         TALLY:         Process 70.WaitTimePerEntity,Diff.WaitTime,1;
4315$         TALLY:         Process 70.TotalTimePerEntity,Diff.StartTime,1;
4339$         ASSIGN:        Process 70.VATime=Process 70.VATime + Diff.VATime;
4340$         TALLY:         Process 70.VATimePerEntity,Diff.VATime,1;
4305$         RELEASE:       Resource 52,1;
4354$         STACK,         1:Destroy:NEXT(4353$);

4353$         ASSIGN:        Process 70.NumberOut=Process 70.NumberOut + 1:
                             Process 70.WIP=Process 70.WIP-1:NEXT(429$);


;
;
;     Model statements for module:  Assign 159
;
429$          ASSIGN:        producttype=3:NEXT(180$);


;
;
;     Model statements for module:  Assign 165
;
451$          ASSIGN:        receiptc2# c5=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,94)
                             :NEXT(455$);


;
;
;     Model statements for module:  Decide 207
;
455$          BRANCH,        1:
                             If,receiptc2# c5==0,432$,Yes:
                             If,receiptc2# c5==1,456$,Yes:
                             Else,457$,Yes;

;
;
;     Model statements for module:  Separate 66
;
457$          DUPLICATE,     100 - 50:
                             receiptc2# c5-1,4360$,50:NEXT(4359$);

4359$         ASSIGN:        Separate 66.NumberOut Orig=Separate 66.NumberOut Orig + 1:NEXT(456$);

4360$         ASSIGN:        Separate 66.NumberOut Dup=Separate 66.NumberOut Dup + 1:NEXT(456$);


;
;
;     Model statements for module:  Process 71
;
456$          ASSIGN:        Process 71.NumberIn=Process 71.NumberIn + 1:
                             Process 71.WIP=Process 71.WIP+1;
4390$         STACK,         1:Save:NEXT(4364$);

4364$         QUEUE,         Process 71.Queue;
4363$         SEIZE,         2,VA:
                             Resource 53,1:NEXT(4362$);

4362$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c5,30)),,VA:NEXT(4405$);

4405$         ASSIGN:        Process 71.WaitTime=Process 71.WaitTime + Diff.WaitTime;
4369$         TALLY:         Process 71.WaitTimePerEntity,Diff.WaitTime,1;
4371$         TALLY:         Process 71.TotalTimePerEntity,Diff.StartTime,1;
4395$         ASSIGN:        Process 71.VATime=Process 71.VATime + Diff.VATime;
4396$         TALLY:         Process 71.VATimePerEntity,Diff.VATime,1;
4361$         RELEASE:       Resource 53,1;
4410$         STACK,         1:Destroy:NEXT(4409$);

4409$         ASSIGN:        Process 71.NumberOut=Process 71.NumberOut + 1:
                             Process 71.WIP=Process 71.WIP-1:NEXT(429$);


;
;
;     Model statements for module:  Create 87
;

4412$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c5:MinutesToBaseTime(1440):NEXT(4413$);

4413$         ASSIGN:        Create for receiving a shift2 c5.NumberOut=Create for receiving a shift2 c5.NumberOut + 1
                             :NEXT(435$);


;
;
;     Model statements for module:  Decide 200
;
435$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4416$,Yes:
                             Else,4417$,Yes;
4416$         ASSIGN:        Decide 200.NumberOut True=Decide 200.NumberOut True + 1:NEXT(430$);

4417$         ASSIGN:        Decide 200.NumberOut False=Decide 200.NumberOut False + 1:NEXT(436$);


;
;
;     Model statements for module:  Assign 160
;
430$          ASSIGN:        receipta1# c5=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,89)
                             :NEXT(431$);


;
;
;     Model statements for module:  Decide 199
;
431$          BRANCH,        1:
                             If,receipta1# c5==0,432$,Yes:
                             If,receipta1# c5==1,433$,Yes:
                             Else,434$,Yes;

;
;
;     Model statements for module:  Separate 61
;
434$          DUPLICATE,     100 - 50:
                             receipta1# c5-1,4422$,50:NEXT(4421$);

4421$         ASSIGN:        Separate 61.NumberOut Orig=Separate 61.NumberOut Orig + 1:NEXT(433$);

4422$         ASSIGN:        Separate 61.NumberOut Dup=Separate 61.NumberOut Dup + 1:NEXT(433$);


;
;
;     Model statements for module:  Process 66
;
433$          ASSIGN:        Process 66.NumberIn=Process 66.NumberIn + 1:
                             Process 66.WIP=Process 66.WIP+1;
4452$         STACK,         1:Save:NEXT(4426$);

4426$         QUEUE,         Process 66.Queue;
4425$         SEIZE,         2,VA:
                             Resource 48,1:NEXT(4424$);

4424$         DELAY:         HoursToBaseTime(expo(10/receipta1# c5,25)),,VA:NEXT(4467$);

4467$         ASSIGN:        Process 66.WaitTime=Process 66.WaitTime + Diff.WaitTime;
4431$         TALLY:         Process 66.WaitTimePerEntity,Diff.WaitTime,1;
4433$         TALLY:         Process 66.TotalTimePerEntity,Diff.StartTime,1;
4457$         ASSIGN:        Process 66.VATime=Process 66.VATime + Diff.VATime;
4458$         TALLY:         Process 66.VATimePerEntity,Diff.VATime,1;
4423$         RELEASE:       Resource 48,1;
4472$         STACK,         1:Destroy:NEXT(4471$);

4471$         ASSIGN:        Process 66.NumberOut=Process 66.NumberOut + 1:
                             Process 66.WIP=Process 66.WIP-1:NEXT(427$);


;
;
;     Model statements for module:  Assign 157
;
427$          ASSIGN:        producttype=1:NEXT(180$);


;
;
;     Model statements for module:  Assign 161
;
436$          ASSIGN:        receipta2# c5=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,90)
                             :NEXT(437$);


;
;
;     Model statements for module:  Decide 201
;
437$          BRANCH,        1:
                             If,receipta2# c5==0,432$,Yes:
                             If,receipta2# c5==1,439$,Yes:
                             Else,438$,Yes;

;
;
;     Model statements for module:  Separate 62
;
438$          DUPLICATE,     100 - 50:
                             receipta2# c5-1,4478$,50:NEXT(4477$);

4477$         ASSIGN:        Separate 62.NumberOut Orig=Separate 62.NumberOut Orig + 1:NEXT(439$);

4478$         ASSIGN:        Separate 62.NumberOut Dup=Separate 62.NumberOut Dup + 1:NEXT(439$);


;
;
;     Model statements for module:  Process 67
;
439$          ASSIGN:        Process 67.NumberIn=Process 67.NumberIn + 1:
                             Process 67.WIP=Process 67.WIP+1;
4508$         STACK,         1:Save:NEXT(4482$);

4482$         QUEUE,         Process 67.Queue;
4481$         SEIZE,         2,VA:
                             Resource 49,1:NEXT(4480$);

4480$         DELAY:         HoursToBaseTime(expo(14/receipta2# c5,26)),,VA:NEXT(4523$);

4523$         ASSIGN:        Process 67.WaitTime=Process 67.WaitTime + Diff.WaitTime;
4487$         TALLY:         Process 67.WaitTimePerEntity,Diff.WaitTime,1;
4489$         TALLY:         Process 67.TotalTimePerEntity,Diff.StartTime,1;
4513$         ASSIGN:        Process 67.VATime=Process 67.VATime + Diff.VATime;
4514$         TALLY:         Process 67.VATimePerEntity,Diff.VATime,1;
4479$         RELEASE:       Resource 49,1;
4528$         STACK,         1:Destroy:NEXT(4527$);

4527$         ASSIGN:        Process 67.NumberOut=Process 67.NumberOut + 1:
                             Process 67.WIP=Process 67.WIP-1:NEXT(427$);


;
;
;     Model statements for module:  Create 88
;

4530$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c5:MinutesToBaseTime(1440):NEXT(4531$);

4531$         ASSIGN:        Create for receiving b shift2 c5.NumberOut=Create for receiving b shift2 c5.NumberOut + 1
                             :NEXT(440$);


;
;
;     Model statements for module:  Create 89
;

4534$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c5:MinutesToBaseTime(1440):NEXT(4535$);

4535$         ASSIGN:        Create for receiving c shift2 c5.NumberOut=Create for receiving c shift2 c5.NumberOut + 1
                             :NEXT(449$);


;
;
;     Model statements for module:  Create 93
;

4538$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c5:MinutesToBaseTime(1440):NEXT(4539$);

4539$         ASSIGN:        Create for shipment b shift1 c5.NumberOut=Create for shipment b shift1 c5.NumberOut + 1:NEXT(471$);


;
;
;     Model statements for module:  Decide 211
;
471$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4542$,Yes:
                             Else,4543$,Yes;
4542$         ASSIGN:        Decide 211.NumberOut True=Decide 211.NumberOut True + 1:NEXT(472$);

4543$         ASSIGN:        Decide 211.NumberOut False=Decide 211.NumberOut False + 1:NEXT(473$);


;
;
;     Model statements for module:  Assign 171
;
472$          ASSIGN:        departureb1# c5=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,121):NEXT(474$);


;
;
;     Model statements for module:  Decide 212
;
474$          BRANCH,        1:
                             If,departureb1# c5==0,465$,Yes:
                             If,departureb1# c5==1,475$,Yes:
                             Else,476$,Yes;

;
;
;     Model statements for module:  Separate 69
;
476$          DUPLICATE,     100 - 50:
                             departureb1# c5-1,4548$,50:NEXT(4547$);

4547$         ASSIGN:        Separate 69.NumberOut Orig=Separate 69.NumberOut Orig + 1:NEXT(475$);

4548$         ASSIGN:        Separate 69.NumberOut Dup=Separate 69.NumberOut Dup + 1:NEXT(475$);


;
;
;     Model statements for module:  Process 74
;
475$          ASSIGN:        Process 74.NumberIn=Process 74.NumberIn + 1:
                             Process 74.WIP=Process 74.WIP+1;
4578$         STACK,         1:Save:NEXT(4552$);

4552$         QUEUE,         Process 74.Queue;
4551$         SEIZE,         2,VA:
                             Resource 56,1:NEXT(4550$);

4550$         DELAY:         HoursToBaseTime(expo(10/departureb1# c5,57)),,VA:NEXT(4593$);

4593$         ASSIGN:        Process 74.WaitTime=Process 74.WaitTime + Diff.WaitTime;
4557$         TALLY:         Process 74.WaitTimePerEntity,Diff.WaitTime,1;
4559$         TALLY:         Process 74.TotalTimePerEntity,Diff.StartTime,1;
4583$         ASSIGN:        Process 74.VATime=Process 74.VATime + Diff.VATime;
4584$         TALLY:         Process 74.VATimePerEntity,Diff.VATime,1;
4549$         RELEASE:       Resource 56,1;
4598$         STACK,         1:Destroy:NEXT(4597$);

4597$         ASSIGN:        Process 74.NumberOut=Process 74.NumberOut + 1:
                             Process 74.WIP=Process 74.WIP-1:NEXT(459$);


;
;
;     Model statements for module:  Assign 167
;
459$          ASSIGN:        type=2:NEXT(158$);


;
;
;     Model statements for module:  Dispose 31
;
465$          ASSIGN:        Dispose 31.NumberOut=Dispose 31.NumberOut + 1;
4600$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 172
;
473$          ASSIGN:        departureb2# c5=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,122)
                             :NEXT(477$);


;
;
;     Model statements for module:  Decide 213
;
477$          BRANCH,        1:
                             If,departureb2# c5==0,465$,Yes:
                             If,departureb2# c5==1,478$,Yes:
                             Else,479$,Yes;

;
;
;     Model statements for module:  Separate 70
;
479$          DUPLICATE,     100 - 50:
                             departureb2# c5-1,4605$,50:NEXT(4604$);

4604$         ASSIGN:        Separate 70.NumberOut Orig=Separate 70.NumberOut Orig + 1:NEXT(478$);

4605$         ASSIGN:        Separate 70.NumberOut Dup=Separate 70.NumberOut Dup + 1:NEXT(478$);


;
;
;     Model statements for module:  Process 75
;
478$          ASSIGN:        Process 75.NumberIn=Process 75.NumberIn + 1:
                             Process 75.WIP=Process 75.WIP+1;
4635$         STACK,         1:Save:NEXT(4609$);

4609$         QUEUE,         Process 75.Queue;
4608$         SEIZE,         2,VA:
                             Resource 57,1:NEXT(4607$);

4607$         DELAY:         HoursToBaseTime(expo(14/departureb2# c5,58)),,VA:NEXT(4650$);

4650$         ASSIGN:        Process 75.WaitTime=Process 75.WaitTime + Diff.WaitTime;
4614$         TALLY:         Process 75.WaitTimePerEntity,Diff.WaitTime,1;
4616$         TALLY:         Process 75.TotalTimePerEntity,Diff.StartTime,1;
4640$         ASSIGN:        Process 75.VATime=Process 75.VATime + Diff.VATime;
4641$         TALLY:         Process 75.VATimePerEntity,Diff.VATime,1;
4606$         RELEASE:       Resource 57,1;
4655$         STACK,         1:Destroy:NEXT(4654$);

4654$         ASSIGN:        Process 75.NumberOut=Process 75.NumberOut + 1:
                             Process 75.WIP=Process 75.WIP-1:NEXT(459$);


;
;
;     Model statements for module:  Create 94
;

4657$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c5:MinutesToBaseTime(1440):NEXT(4658$);

4658$         ASSIGN:        Create for shipment c shift1 c5.NumberOut=Create for shipment c shift1 c5.NumberOut + 1:NEXT(480$);


;
;
;     Model statements for module:  Decide 214
;
480$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4661$,Yes:
                             Else,4662$,Yes;
4661$         ASSIGN:        Decide 214.NumberOut True=Decide 214.NumberOut True + 1:NEXT(481$);

4662$         ASSIGN:        Decide 214.NumberOut False=Decide 214.NumberOut False + 1:NEXT(482$);


;
;
;     Model statements for module:  Assign 173
;
481$          ASSIGN:        departurec1# c5=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,123):NEXT(483$);


;
;
;     Model statements for module:  Decide 215
;
483$          BRANCH,        1:
                             If,departurec1# c5==0,465$,Yes:
                             If,departurec1# c5==1,484$,Yes:
                             Else,485$,Yes;

;
;
;     Model statements for module:  Separate 71
;
485$          DUPLICATE,     100 - 50:
                             departurec1# c5-1,4667$,50:NEXT(4666$);

4666$         ASSIGN:        Separate 71.NumberOut Orig=Separate 71.NumberOut Orig + 1:NEXT(484$);

4667$         ASSIGN:        Separate 71.NumberOut Dup=Separate 71.NumberOut Dup + 1:NEXT(484$);


;
;
;     Model statements for module:  Process 76
;
484$          ASSIGN:        Process 76.NumberIn=Process 76.NumberIn + 1:
                             Process 76.WIP=Process 76.WIP+1;
4697$         STACK,         1:Save:NEXT(4671$);

4671$         QUEUE,         Process 76.Queue;
4670$         SEIZE,         2,VA:
                             Resource 58,1:NEXT(4669$);

4669$         DELAY:         HoursToBaseTime(expo(10/departurec1# c5,59)),,VA:NEXT(4712$);

4712$         ASSIGN:        Process 76.WaitTime=Process 76.WaitTime + Diff.WaitTime;
4676$         TALLY:         Process 76.WaitTimePerEntity,Diff.WaitTime,1;
4678$         TALLY:         Process 76.TotalTimePerEntity,Diff.StartTime,1;
4702$         ASSIGN:        Process 76.VATime=Process 76.VATime + Diff.VATime;
4703$         TALLY:         Process 76.VATimePerEntity,Diff.VATime,1;
4668$         RELEASE:       Resource 58,1;
4717$         STACK,         1:Destroy:NEXT(4716$);

4716$         ASSIGN:        Process 76.NumberOut=Process 76.NumberOut + 1:
                             Process 76.WIP=Process 76.WIP-1:NEXT(460$);


;
;
;     Model statements for module:  Assign 168
;
460$          ASSIGN:        type=3:NEXT(158$);


;
;
;     Model statements for module:  Assign 174
;
482$          ASSIGN:        departurec2# c5=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,124):NEXT(486$);


;
;
;     Model statements for module:  Decide 216
;
486$          BRANCH,        1:
                             If,departurec2# c5==0,465$,Yes:
                             If,departurec2# c5==1,487$,Yes:
                             Else,488$,Yes;

;
;
;     Model statements for module:  Separate 72
;
488$          DUPLICATE,     100 - 50:
                             departurec2# c5-1,4723$,50:NEXT(4722$);

4722$         ASSIGN:        Separate 72.NumberOut Orig=Separate 72.NumberOut Orig + 1:NEXT(487$);

4723$         ASSIGN:        Separate 72.NumberOut Dup=Separate 72.NumberOut Dup + 1:NEXT(487$);


;
;
;     Model statements for module:  Process 77
;
487$          ASSIGN:        Process 77.NumberIn=Process 77.NumberIn + 1:
                             Process 77.WIP=Process 77.WIP+1;
4753$         STACK,         1:Save:NEXT(4727$);

4727$         QUEUE,         Process 77.Queue;
4726$         SEIZE,         2,VA:
                             Resource 59,1:NEXT(4725$);

4725$         DELAY:         HoursToBaseTime(expo(14/departurec2# c5,60)),,VA:NEXT(4768$);

4768$         ASSIGN:        Process 77.WaitTime=Process 77.WaitTime + Diff.WaitTime;
4732$         TALLY:         Process 77.WaitTimePerEntity,Diff.WaitTime,1;
4734$         TALLY:         Process 77.TotalTimePerEntity,Diff.StartTime,1;
4758$         ASSIGN:        Process 77.VATime=Process 77.VATime + Diff.VATime;
4759$         TALLY:         Process 77.VATimePerEntity,Diff.VATime,1;
4724$         RELEASE:       Resource 59,1;
4773$         STACK,         1:Destroy:NEXT(4772$);

4772$         ASSIGN:        Process 77.NumberOut=Process 77.NumberOut + 1:
                             Process 77.WIP=Process 77.WIP-1:NEXT(460$);


;
;
;     Model statements for module:  Create 96
;

4775$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c5:MinutesToBaseTime(1440):NEXT(4776$);

4776$         ASSIGN:        Create for shipmenta shift2 c5.NumberOut=Create for shipmenta shift2 c5.NumberOut + 1:NEXT(462$);


;
;
;     Model statements for module:  Decide 208
;
462$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4779$,Yes:
                             Else,4780$,Yes;
4779$         ASSIGN:        Decide 208.NumberOut True=Decide 208.NumberOut True + 1:NEXT(461$);

4780$         ASSIGN:        Decide 208.NumberOut False=Decide 208.NumberOut False + 1:NEXT(463$);


;
;
;     Model statements for module:  Assign 169
;
461$          ASSIGN:        departurea1# c5=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,119):NEXT(464$);


;
;
;     Model statements for module:  Decide 209
;
464$          BRANCH,        1:
                             If,departurea1# c5==0,465$,Yes:
                             If,departurea1# c5==1,466$,Yes:
                             Else,467$,Yes;

;
;
;     Model statements for module:  Separate 67
;
467$          DUPLICATE,     100 - 50:
                             departurea1# c5-1,4785$,50:NEXT(4784$);

4784$         ASSIGN:        Separate 67.NumberOut Orig=Separate 67.NumberOut Orig + 1:NEXT(466$);

4785$         ASSIGN:        Separate 67.NumberOut Dup=Separate 67.NumberOut Dup + 1:NEXT(466$);


;
;
;     Model statements for module:  Process 72
;
466$          ASSIGN:        Process 72.NumberIn=Process 72.NumberIn + 1:
                             Process 72.WIP=Process 72.WIP+1;
4815$         STACK,         1:Save:NEXT(4789$);

4789$         QUEUE,         Process 72.Queue;
4788$         SEIZE,         2,VA:
                             Resource 54,1:NEXT(4787$);

4787$         DELAY:         HoursToBaseTime(expo(10/departurea1# c5,55)),,VA:NEXT(4830$);

4830$         ASSIGN:        Process 72.WaitTime=Process 72.WaitTime + Diff.WaitTime;
4794$         TALLY:         Process 72.WaitTimePerEntity,Diff.WaitTime,1;
4796$         TALLY:         Process 72.TotalTimePerEntity,Diff.StartTime,1;
4820$         ASSIGN:        Process 72.VATime=Process 72.VATime + Diff.VATime;
4821$         TALLY:         Process 72.VATimePerEntity,Diff.VATime,1;
4786$         RELEASE:       Resource 54,1;
4835$         STACK,         1:Destroy:NEXT(4834$);

4834$         ASSIGN:        Process 72.NumberOut=Process 72.NumberOut + 1:
                             Process 72.WIP=Process 72.WIP-1:NEXT(458$);


;
;
;     Model statements for module:  Assign 166
;
458$          ASSIGN:        type=1:NEXT(158$);


;
;
;     Model statements for module:  Assign 170
;
463$          ASSIGN:        departurea2# c5=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,120):NEXT(468$);


;
;
;     Model statements for module:  Decide 210
;
468$          BRANCH,        1:
                             If,departurea2# c5==0,465$,Yes:
                             If,departurea2# c5==1,470$,Yes:
                             Else,469$,Yes;

;
;
;     Model statements for module:  Separate 68
;
469$          DUPLICATE,     100 - 50:
                             departurea2# c5-1,4841$,50:NEXT(4840$);

4840$         ASSIGN:        Separate 68.NumberOut Orig=Separate 68.NumberOut Orig + 1:NEXT(470$);

4841$         ASSIGN:        Separate 68.NumberOut Dup=Separate 68.NumberOut Dup + 1:NEXT(470$);


;
;
;     Model statements for module:  Process 73
;
470$          ASSIGN:        Process 73.NumberIn=Process 73.NumberIn + 1:
                             Process 73.WIP=Process 73.WIP+1;
4871$         STACK,         1:Save:NEXT(4845$);

4845$         QUEUE,         Process 73.Queue;
4844$         SEIZE,         2,VA:
                             Resource 55,1:NEXT(4843$);

4843$         DELAY:         HoursToBaseTime(expo(14/departurea2# c5,56)),,VA:NEXT(4886$);

4886$         ASSIGN:        Process 73.WaitTime=Process 73.WaitTime + Diff.WaitTime;
4850$         TALLY:         Process 73.WaitTimePerEntity,Diff.WaitTime,1;
4852$         TALLY:         Process 73.TotalTimePerEntity,Diff.StartTime,1;
4876$         ASSIGN:        Process 73.VATime=Process 73.VATime + Diff.VATime;
4877$         TALLY:         Process 73.VATimePerEntity,Diff.VATime,1;
4842$         RELEASE:       Resource 55,1;
4891$         STACK,         1:Destroy:NEXT(4890$);

4890$         ASSIGN:        Process 73.NumberOut=Process 73.NumberOut + 1:
                             Process 73.WIP=Process 73.WIP-1:NEXT(458$);


;
;
;     Model statements for module:  Create 97
;

4893$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c5:MinutesToBaseTime(1440):NEXT(4894$);

4894$         ASSIGN:        Create for shipment b shift2 c5.NumberOut=Create for shipment b shift2 c5.NumberOut + 1:NEXT(471$);


;
;
;     Model statements for module:  Create 99
;

4897$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c2:MinutesToBaseTime(1440):NEXT(4898$);

4898$         ASSIGN:        Create for receiving a shift1 c2.NumberOut=Create for receiving a shift1 c2.NumberOut + 1
                             :NEXT(240$);


;
;
;     Model statements for module:  Create 100
;

4901$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c1:MinutesToBaseTime(1440):NEXT(4902$);

4902$         ASSIGN:        Create for receiving a shift1 c1.NumberOut=Create for receiving a shift1 c1.NumberOut + 1
                             :NEXT(100$);


;
;
;     Model statements for module:  Create 101
;

4905$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c1:MinutesToBaseTime(1440):NEXT(4906$);

4906$         ASSIGN:        Create for shipmenta shift1 c1.NumberOut=Create for shipmenta shift1 c1.NumberOut + 1:NEXT(105$);


;
;
;     Model statements for module:  Create 102
;

4909$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c2:MinutesToBaseTime(1440):NEXT(4910$);

4910$         ASSIGN:        Create for shipmenta shift1 c2.NumberOut=Create for shipmenta shift1 c2.NumberOut + 1:NEXT(266$);


;
;
;     Model statements for module:  Create 103
;

4913$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c3:MinutesToBaseTime(1440):NEXT(4914$);

4914$         ASSIGN:        Create for receiving a shift1 c3.NumberOut=Create for receiving a shift1 c3.NumberOut + 1
                             :NEXT(311$);


;
;
;     Model statements for module:  Create 104
;

4917$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c3:MinutesToBaseTime(1440):NEXT(4918$);

4918$         ASSIGN:        Create for shipmenta shift1 c3.NumberOut=Create for shipmenta shift1 c3.NumberOut + 1:NEXT(338$);


;
;
;     Model statements for module:  Create 105
;

4921$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c4:MinutesToBaseTime(1440):NEXT(4922$);

4922$         ASSIGN:        Create for receiving a shift1 c4.NumberOut=Create for receiving a shift1 c4.NumberOut + 1
                             :NEXT(373$);


;
;
;     Model statements for module:  Create 106
;

4925$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c4:MinutesToBaseTime(1440):NEXT(4926$);

4926$         ASSIGN:        Create for shipmenta shift1 c4.NumberOut=Create for shipmenta shift1 c4.NumberOut + 1:NEXT(400$);


;
;
;     Model statements for module:  Create 107
;

4929$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c5:MinutesToBaseTime(1440):NEXT(4930$);

4930$         ASSIGN:        Create for receiving a shift1 c5.NumberOut=Create for receiving a shift1 c5.NumberOut + 1
                             :NEXT(435$);


;
;
;     Model statements for module:  Create 108
;

4933$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c5:MinutesToBaseTime(1440):NEXT(4934$);

4934$         ASSIGN:        Create for shipmenta shift1 c5.NumberOut=Create for shipmenta shift1 c5.NumberOut + 1:NEXT(462$);


;
;
;     Model statements for module:  Create 109
;

4937$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c1:MinutesToBaseTime(1440):NEXT(4938$);

4938$         ASSIGN:        Create for shipment c shift2 c1.NumberOut=Create for shipment c shift2 c1.NumberOut + 1:NEXT(141$);


;
;
;     Model statements for module:  Create 110
;

4941$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c2:MinutesToBaseTime(1440):NEXT(4942$);

4942$         ASSIGN:        Create for shipment c shift2 c2.NumberOut=Create for shipment c shift2 c2.NumberOut + 1:NEXT(284$);


;
;
;     Model statements for module:  Create 111
;

4945$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c3:MinutesToBaseTime(1440):NEXT(4946$);

4946$         ASSIGN:        Create for shipment c shift2 c3.NumberOut=Create for shipment c shift2 c3.NumberOut + 1:NEXT(356$);


;
;
;     Model statements for module:  Create 112
;

4949$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c4:MinutesToBaseTime(1440):NEXT(4950$);

4950$         ASSIGN:        Create for shipment c shift2 c4.NumberOut=Create for shipment c shift2 c4.NumberOut + 1:NEXT(418$);


;
;
;     Model statements for module:  Create 113
;

4953$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c5:MinutesToBaseTime(1440):NEXT(4954$);

4954$         ASSIGN:        Create for shipment c shift2 c5.NumberOut=Create for shipment c shift2 c5.NumberOut + 1:NEXT(480$);









